/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (https://www.swig.org).
 * Version 4.4.1
 *
 * Do not make changes to this file unless you know what you are doing - modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */

#include "../source/Plugins/ScriptInterpreter/Python/lldb-python.h"



#define SWIG_VERSION 0x040401
#define SWIGPYTHON
#define SWIG_PYTHON_THREADS
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE

#define SWIG_name    "_lldb"
/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__))
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__))
# else
#   define SWIGUNUSED
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if defined(__GNUC__)
#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#    ifndef GCC_HASCLASSVISIBILITY
#      define GCC_HASCLASSVISIBILITY
#    endif
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif

/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif

/* Intel's compiler complains if a variable which was never initialised is
 * cast to void, which is a common idiom which we use to indicate that we
 * are aware a variable isn't used.  So we just silence that warning.
 * See: https://github.com/swig/swig/issues/192 for more discussion.
 */
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif

#if defined(__cplusplus) && __cplusplus >=201103L
# define SWIG_NOEXCEPT noexcept
#else
# define SWIG_NOEXCEPT throw()
#endif 

/* -----------------------------------------------------------------------------
 * swigcompat.swg
 *
 * Macros to provide support compatibility with older C and C++ standards.
 *
 * Note that SWIG expects __cplusplus to be defined to the appropriate C++ standard.
 * MSVC users are urged to check and examine the /Zc:__cplusplus compiler option.
 * See https://learn.microsoft.com/en-us/cpp/build/reference/zc-cplusplus.
 * ----------------------------------------------------------------------------- */

/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
 * if you're missing it.
 */
#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
     (defined __cplusplus && __cplusplus >= 201103L) || \
     defined SWIG_HAVE_SNPRINTF) && \
    !defined SWIG_NO_SNPRINTF
# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
#else
/* Fallback versions ignore the buffer size, but most of our uses either have a
 * fixed maximum possible size or dynamically allocate a buffer that's large
 * enough.
 */
# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
#endif


#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include <math.h>
#endif

#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif

#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif

#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */

#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
 * See https://github.com/swig/swig/issues/2090 */
# include <corecrt.h>
#endif

# undef _DEBUG
# include <Python.h>
# define _DEBUG 1
#else
# include <Python.h>
#endif


#if __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif

#include <stdio.h>
#include <stdlib.h>

/* -----------------------------------------------------------------------------
 * swigrun.swg
 *
 * This file contains generic C API SWIG runtime support for pointer
 * type checking.
 * ----------------------------------------------------------------------------- */

/* This should only be incremented when either the layout of swig_type_info changes,
   or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "5"

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif

/*
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  creating a static or dynamic library from the SWIG runtime code.
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.

  But only do this if strictly necessary, ie, if you have problems
  with your compiler or suchlike.
*/

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

/*  Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif

/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN        0x1
#define SWIG_CAST_NEW_MEMORY       0x2
#define SWIG_POINTER_NO_NULL       0x4
#define SWIG_POINTER_CLEAR         0x8
#define SWIG_POINTER_RELEASE       (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)

/* Flags for new pointer objects */
#define SWIG_POINTER_OWN           0x1


/*
   Flags/methods for returning states.

   The SWIG conversion methods, as ConvertPtr, return an integer
   that tells if the conversion was successful or not. And if not,
   an error code can be returned (see swigerrors.swg for the codes).

   Use the following macros/flags to set or process the returning
   states.

   In old versions of SWIG, code such as the following was usually written:

     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
       // success code
     } else {
       //fail code
     }

   Now you can be more explicit:

    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
    } else {
      // fail code
    }

   which is the same really, but now you can also do

    Type *ptr;
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
      if (SWIG_IsNewObj(res) {
        ...
	delete *ptr;
      } else {
        ...
      }
    } else {
      // fail code
    }

   I.e., now SWIG_ConvertPtr can return new objects and you can
   identify the case and take care of the deallocation. Of course that
   also requires SWIG_ConvertPtr to return new result values, such as

      int SWIG_ConvertPtr(obj, ptr,...) {
        if (<obj is ok>) {
          if (<need new object>) {
            *ptr = <ptr to new allocated object>;
            return SWIG_NEWOBJ;
          } else {
            *ptr = <ptr to old object>;
            return SWIG_OLDOBJ;
          }
        } else {
          return SWIG_BADOBJ;
        }
      }

   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
   SWIG errors code.

   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
   allows returning the 'cast rank', for example, if you have this

       int food(double)
       int fooi(int);

   and you call

      food(1)   // cast rank '1'  (1 -> 1.0)
      fooi(1)   // cast rank '0'

   just use the SWIG_AddCast()/SWIG_CheckState()
*/

#define SWIG_OK                    (0)
/* Runtime errors are < 0 */
#define SWIG_ERROR                 (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)

#define SWIG_IsOK(r)               (r >= 0)
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)

/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT         (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
/* The TmpMask is for in/out typemaps that use temporary objects */
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ                (SWIG_ERROR)
#define SWIG_OLDOBJ                (SWIG_OK)
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del object mask methods */
#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))

/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
#  ifndef SWIG_TypeRank
#    define SWIG_TypeRank             unsigned long
#  endif
#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
#    define SWIG_MAXCASTRANK          (2)
#  endif
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
#  define SWIG_AddCast(r) (r)
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);

/* Structure to store information on one type */
typedef struct swig_type_info {
  const char             *name;			/* mangled name of this type */
  const char             *str;			/* human readable name of this type */
  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
  void                   *clientdata;		/* language specific type data */
  int                    owndata;		/* flag if the structure owns the clientdata */
} swig_type_info;

/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
  swig_converter_func     converter;		/* function to cast the void pointers */
  struct swig_cast_info  *next;			/* pointer to next array of casts | pointer to cast hashed by value */
  unsigned int            value;		/* index of the last valid element in the array | typename hash value */
} swig_cast_info;

/* Structure used to store module information
 * Each module generates one structure like this, and the runtime collects
 * all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
  size_t                 size;		        /* Number of types in this module */
  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
  swig_type_info         **type_initial;	/* Array of initially generated type structures */
  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
  void                    *clientdata;		/* Language specific module data */
} swig_module_info;

/*
  Compare two type names skipping the space characters, therefore
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.

  Return 0 when the two name types are equivalent, as in
  strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
		  const char *f2, const char *l2) {
  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
    while ((*f1 == ' ') && (f1 != l1)) ++f1;
    while ((*f2 == ' ') && (f2 != l2)) ++f2;
    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
  }
  return (int)((l1 - f1) - (l2 - f2));
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
  int equiv = 1;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (equiv != 0 && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
    if (*ne) ++ne;
  }
  return equiv;
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}

/*
 * Hash function for type name strings, based on maRushPrime1Hash (http://amsoftware.narod.ru/algo2.html)
 */
SWIGRUNTIME unsigned int SWIG_Hash(const char *str, unsigned int len) {
  const unsigned char *data = (const unsigned char *)str;
  unsigned int hash = len, i = 0, k;
  int rem = (int)len;

  while (rem >= (int)sizeof(unsigned int)) {
    memcpy(&k, data, sizeof(unsigned int));
    k += i++;
    hash ^= k;
    hash *= 171717;
    data += sizeof(unsigned int);
    rem -= sizeof(unsigned int);
  }

  switch (rem) {
    case 3: k = (unsigned int)(data[2]) << 16;
            k |= (unsigned int)(data[1]) << 8;
            k |= (unsigned int)(data[0]);
            k += i++;
            hash ^= k;
            hash *= 171717;
            break;
    case 2: k = (unsigned int)(data[1]) << 8;
            k |= (unsigned int)(data[0]);
            k += i++;
            hash ^= k;
            hash *= 171717;
            break;
    case 1: k = (unsigned int)(data[0]);
            k += i++;
            hash ^= k;
            hash *= 171717;
            break;
  }
  return hash;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  static const unsigned int scan_threshold = 4;
  if (ty) {
    swig_cast_info *head = ty->cast;
    unsigned int hash_value = 0;
    int hashed = 0;

    while (head) {

      if (strcmp(head->type->name, c) == 0) {
        return head;
      }

      if (head->value) {
        swig_cast_info *iter;
        swig_cast_info *last = head + head->value;
        swig_cast_info *first = head + 1;
        int search = 1;

        if (!hashed) {
          if (head->value < scan_threshold) {
            for (iter = first; iter <= last; iter++) {
              if (strcmp(iter->type->name, c) == 0) {
                return iter;
              }
            }
            search = 0;
          } else {
            hashed = 1;
            hash_value = SWIG_Hash(c, (unsigned int)strlen(c));
          }
        }

        if (search) {
          /* Binary search over sorted <'next'|'value'> pairs */
          do {
            iter = first + ((last - first) >> 1);
            if (iter->value < hash_value) {
              first = iter + 1;
            } else if (iter->value == hash_value) {

              if (strcmp(iter->next->type->name, c) == 0) {
                return iter->next;
              }

              /* Hash collision check */
              for (last = iter + 1; last->next && last->value == hash_value; last++) {
                if (strcmp(last->next->type->name, c) == 0) {
                  return last->next;
                }
              }
              for (first = iter - 1; first != head && first->value == hash_value; first--) {
                if (strcmp(first->next->type->name, c) == 0) {
                  return first->next;
                }
              }
              break;
            } else
              last = iter - 1;
          } while (first <= last);
        }
      }
      head = head->next;
    }
  }
  return 0;
}

/*
  Check the type by type address
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *head = ty->cast;
    while (head) {
      if (head->type == from) {
        return head;
      }

      if (head->value) {
        swig_cast_info *iter;
        swig_cast_info *last = head + head->value;
        swig_cast_info *first = head + 1;

        /* Binary search over sorted array of casts */
        do {
          iter = first + ((last - first) >> 1);
          if (iter->type < from) {
            first = iter + 1;
          } else if (iter->type == from) {
            return iter;
          } else
            last = iter - 1;
        } while (first <= last);
      }
      head = head->next;
    }
  }
  return 0;
}

/*
  Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}

/*
   Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
  swig_type_info *lastty = ty;
  if (!ty || !ty->dcast) return ty;
  while (ty && (ty->dcast)) {
    ty = (*ty->dcast)(ptr);
    if (ty) lastty = ty;
  }
  return lastty;
}

/*
  Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/*
  Return the pretty name associated with this type,
  that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
  /* The "str" field contains the equivalent pretty names of the
     type, separated by vertical-bar characters.  Choose the last
     name. It should be the most specific; a fully resolved name
     but not necessarily with default template parameters expanded. */
  if (!type) return NULL;
  if (type->str != NULL) {
    const char *last_name = type->str;
    const char *s;
    for (s = type->str; *s; s++)
      if (*s == '|') last_name = s+1;
    return last_name;
  }
  else
    return type->name;
}

/*
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_cast_info *head = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;

  while (head) {
    swig_cast_info *cast;
    for (cast = head; (cast - head) <= head->value; cast++) {
      if (!cast->converter) {
        swig_type_info *tc = cast->type;
        if (!tc->clientdata) {
          SWIG_TypeClientData(tc, clientdata);
        }
      }
    }
    head = head->next;
  }
}

SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}

/*
  Search for a swig_type_info structure only by mangled name
  Search is a O(log #types)

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
                            swig_module_info *end,
		            const char *name) {
  swig_module_info *iter = start;
  do {
    if (iter->size) {
      size_t l = 0;
      size_t r = iter->size - 1;
      do {
	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
	size_t i = (l + r) >> 1;
	const char *iname = iter->types[i]->name;
	if (iname) {
	  int compare = strcmp(name, iname);
	  if (compare == 0) {
	    return iter->types[i];
	  } else if (compare < 0) {
	    if (i) {
	      r = i - 1;
	    } else {
	      break;
	    }
	  } else if (compare > 0) {
	    l = i + 1;
	  }
	} else {
	  break; /* should never happen */
	}
      } while (l <= r);
    }
    iter = iter->next;
  } while (iter != end);
  return 0;
}

/*
  Search for a swig_type_info structure for either a mangled name or a human readable name.
  It first searches the mangled names of the types, which is a O(log #types)
  If a type is not found it then searches the human readable names, which is O(#types).

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
                     swig_module_info *end,
		     const char *name) {
  /* STEP 1: Search the name field using binary search */
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
  if (ret) {
    return ret;
  } else {
    /* STEP 2: If the type hasn't been found, do a complete search
       of the str field (the human readable name) */
    swig_module_info *iter = start;
    do {
      size_t i = 0;
      for (; i < iter->size; ++i) {
	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
	  return iter->types[i];
      }
      iter = iter->next;
    } while (iter != end);
  }

  /* neither found a match */
  return 0;
}

/*
   Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
  static const char hex[17] = "0123456789abcdef";
  const unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu =  u + sz;
  for (; u != eu; ++u) {
    unsigned char uu = *u;
    *(c++) = hex[(uu & 0xf0) >> 4];
    *(c++) = hex[uu & 0xf];
  }
  return c;
}

/*
   Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
  unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu = u + sz;
  for (; u != eu; ++u) {
    char d = *(c++);
    unsigned char uu;
    if ((d >= '0') && (d <= '9'))
      uu = (unsigned char)((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = (unsigned char)((d - ('a'-10)) << 4);
    else
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (unsigned char)(d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (unsigned char)(d - ('a'-10));
    else
      return (char *) 0;
    *u = uu;
  }
  return c;
}

/*
   Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
  char *r = buff;
  if ((2*sizeof(void *) + 2) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,&ptr,sizeof(void *));
  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
  strcpy(r,name);
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      *ptr = (void *) 0;
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sizeof(void *));
}

SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
  char *r = buff;
  size_t lname = (name ? strlen(name) : 0);
  if ((2*sz + 2 + lname) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,ptr,sz);
  if (lname) {
    strncpy(r,name,lname+1);
  } else {
    *r = 0;
  }
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      memset(ptr,0,sz);
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sz);
}

#ifdef __cplusplus
}
#endif

/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#define  SWIG_UnknownError    	   -1
#define  SWIG_IOError        	   -2
#define  SWIG_RuntimeError   	   -3
#define  SWIG_IndexError     	   -4
#define  SWIG_TypeError      	   -5
#define  SWIG_DivisionByZero 	   -6
#define  SWIG_OverflowError  	   -7
#define  SWIG_SyntaxError    	   -8
#define  SWIG_ValueError     	   -9
#define  SWIG_SystemError    	   -10
#define  SWIG_AttributeError 	   -11
#define  SWIG_MemoryError    	   -12
#define  SWIG_NullReferenceError   -13


#if PY_VERSION_HEX >= 0x03030000 && !defined(SWIG_NO_HEAPTYPES)
#if !defined(SWIG_HEAPTYPES)
#define SWIG_HEAPTYPES
#endif
#endif

/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000

#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)	
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)

#endif

/* SWIG APIs for compatibility of both Python 2 & 3 */

#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
#  define SWIG_Python_str_FromFormat PyString_FromFormat
#endif

#if defined(SWIG_HEAPTYPES)
#if PY_VERSION_HEX < 0x030c0000
#include <structmember.h>
#define Py_READONLY READONLY
#define Py_T_PYSSIZET T_PYSSIZET
#endif
#endif

#include <stddef.h> /* For offsetof */


/* Wrapper around PyUnicode_AsUTF8AndSize - call Py_XDECREF on the returned pbytes when finished with the returned string */
SWIGINTERN const char *
SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
{
#if PY_VERSION_HEX >= 0x03030000
# if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000
  *pbytes = NULL;
  return PyUnicode_AsUTF8AndSize(str, psize);
# else
  const char *chars;
  *pbytes = PyUnicode_AsUTF8String(str);
  chars = *pbytes ? PyBytes_AsString(*pbytes) : NULL;
  if (chars && psize)
    *psize = PyBytes_Size(*pbytes);
  return chars;
# endif
#else
  char *chars = NULL;
  *pbytes = NULL;
  PyString_AsStringAndSize(str, &chars, psize);
  return chars;
#endif
}

SWIGINTERN PyObject *
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_FromString(c); 
#else
  return PyString_FromString(c);
#endif
}

#define SWIG_RUNTIME_MODULE "swig_runtime_data" SWIG_RUNTIME_VERSION

/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
# define SWIGPY_USE_CAPSULE
#ifdef SWIGPYTHON_BUILTIN
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
#else
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
#endif
#define SWIGPY_CAPSULE_NAME SWIG_RUNTIME_MODULE "." SWIGPY_CAPSULE_ATTR_NAME

#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif

#if defined(Py_LIMITED_API)
# define PyTuple_GET_ITEM PyTuple_GetItem
/* Note that PyTuple_SetItem() has different semantics from PyTuple_SET_ITEM as it decref's the original tuple item, so in general they cannot be used
  interchangeably. However in SWIG-generated code PyTuple_SET_ITEM is only used with newly initialized tuples without any items and for them this does work. */
# define PyTuple_SET_ITEM PyTuple_SetItem
# define PyTuple_GET_SIZE PyTuple_Size
# define PyCFunction_GET_FLAGS PyCFunction_GetFlags
# define PyCFunction_GET_FUNCTION PyCFunction_GetFunction
# define PyCFunction_GET_SELF PyCFunction_GetSelf
# define PyList_GET_ITEM PyList_GetItem
# define PyList_SET_ITEM PyList_SetItem
# define PySliceObject PyObject
#endif

/* Increment and Decrement wrappers - for portability when using the stable abi and for performance otherwise */
#ifdef Py_LIMITED_API
# define SWIG_Py_INCREF Py_IncRef
# define SWIG_Py_XINCREF Py_IncRef
# define SWIG_Py_DECREF Py_DecRef
# define SWIG_Py_XDECREF Py_DecRef
#else
# define SWIG_Py_INCREF Py_INCREF
# define SWIG_Py_XINCREF Py_XINCREF
# define SWIG_Py_DECREF Py_DECREF
# define SWIG_Py_XDECREF Py_XDECREF
#endif

#if PY_VERSION_HEX >= 0x03000000
#if (PY_VERSION_HEX >= 0x030d00a6) && (!defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030d00a6)
# define SWIG_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName
#else
SWIGINTERN PyObject *
SWIG_PyType_GetFullyQualifiedName(PyTypeObject *type) {
  PyObject *result = NULL;
  PyObject *qualname = PyObject_GetAttrString((PyObject *)type, "__qualname__");
  if (qualname) {
    PyObject *mod = PyObject_GetAttrString((PyObject *)type, "__module__");
    if (mod) {
      if (PyUnicode_Check(mod) && PyUnicode_CompareWithASCIIString(mod, "builtins") && PyUnicode_CompareWithASCIIString(mod, "__main__")) {
        result = PyUnicode_FromFormat("%U%c%U", mod, '.', qualname);
        SWIG_Py_DECREF(qualname);
      } else {
        result = qualname;
      }
      SWIG_Py_DECREF(mod);
    } else {
      result = qualname;
    }
  }

  return result;
}
#endif
#endif

/* gh-114329 added PyList_GetItemRef() to Python 3.13.0a4 */
#if (PY_VERSION_HEX >= 0x030d00a4) && (!defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030d00a4)
# define SWIG_PyList_GetItemRef PyList_GetItemRef
#else
SWIGINTERN PyObject *
SWIG_PyList_GetItemRef(PyObject *op, Py_ssize_t index) {
  PyObject *item = PyList_GetItem(op, index);
  Py_XINCREF(item);
  return item;
}
#endif

/* gh-106004 added PyDict_GetItemRef() and PyDict_GetItemStringRef() to Python 3.13.0a1
   functions are renamed here for compatibility with abi3audit */
#if (PY_VERSION_HEX >= 0x030d00a1) && (!defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030d00a1)
# define SWIG_PyDict_GetItemRef PyDict_GetItemRef
# define SWIG_PyDict_GetItemStringRef PyDict_GetItemStringRef
#else
SWIGINTERN int
SWIG_PyDict_GetItemRef(PyObject *mp, PyObject *key, PyObject **result) {
#if PY_VERSION_HEX >= 0x03000000
  PyObject *item = PyDict_GetItemWithError(mp, key);
#else
  PyObject *item = _PyDict_GetItemWithError(mp, key);
#endif
  if (item != NULL) {
    *result = (PyObject *)(item);
    SWIG_Py_INCREF(*result);
    return 1;
  }
  if (!PyErr_Occurred()) {
    *result = NULL;
    return 0;
  }
  *result = NULL;
  return -1;
}

SWIGINTERN int
SWIG_PyDict_GetItemStringRef(PyObject *mp, const char *key, PyObject **result) {
  int res;
#if PY_VERSION_HEX >= 0x03000000
  PyObject *key_obj = PyUnicode_FromString(key);
#else
  PyObject *key_obj = PyString_FromString(key);
#endif
  if (key_obj == NULL) {
    *result = NULL;
    return -1;
  }
  res = SWIG_PyDict_GetItemRef(mp, key_obj, result);
  Py_DECREF(key_obj);
  return res;
}
#endif

/* -----------------------------------------------------------------------------
 * error manipulation
 * ----------------------------------------------------------------------------- */

SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
  PyObject* type = 0;
  switch(code) {
  case SWIG_MemoryError:
    type = PyExc_MemoryError;
    break;
  case SWIG_IOError:
    type = PyExc_IOError;
    break;
  case SWIG_RuntimeError:
    type = PyExc_RuntimeError;
    break;
  case SWIG_IndexError:
    type = PyExc_IndexError;
    break;
  case SWIG_TypeError:
    type = PyExc_TypeError;
    break;
  case SWIG_DivisionByZero:
    type = PyExc_ZeroDivisionError;
    break;
  case SWIG_OverflowError:
    type = PyExc_OverflowError;
    break;
  case SWIG_SyntaxError:
    type = PyExc_SyntaxError;
    break;
  case SWIG_ValueError:
    type = PyExc_ValueError;
    break;
  case SWIG_SystemError:
    type = PyExc_SystemError;
    break;
  case SWIG_AttributeError:
    type = PyExc_AttributeError;
    break;
  case SWIG_NullReferenceError:
    type = PyExc_TypeError;
    break;
  default:
    type = PyExc_RuntimeError;
  }
  return type;
}


SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
  PyObject *type = 0;
  PyObject *value = 0;
  PyObject *traceback = 0;

  if (PyErr_Occurred())
    PyErr_Fetch(&type, &value, &traceback);
  if (value) {
    PyObject *old_str = PyObject_Str(value);
    PyObject *bytes = NULL;
    const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
    PyErr_Clear();
    SWIG_Py_XINCREF(type);
    if (tmp)
      PyErr_Format(type, "%s %s", tmp, mesg);
    else
      PyErr_Format(type, "%s", mesg);
    SWIG_Py_XDECREF(bytes);
    SWIG_Py_DECREF(old_str);
    SWIG_Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
  PyObject *error;
  if (obj)
    return 0;
  error = PyErr_Occurred();
  return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}

SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
  if (SWIG_Python_TypeErrorOccurred(NULL)) {
    /* Use existing TypeError to preserve stacktrace and enhance with given message */
    PyObject *newvalue;
    PyObject *type = NULL, *value = NULL, *traceback = NULL;
    PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
    newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
    newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
    if (newvalue) {
      SWIG_Py_XDECREF(value);
      PyErr_Restore(type, newvalue, traceback);
    } else {
      PyErr_Restore(type, value, traceback);
    }
  } else {
    /* Raise TypeError using given message */
    PyErr_SetString(PyExc_TypeError, message);
  }
}

#if defined(SWIG_PYTHON_NO_THREADS)
#  if defined(SWIG_PYTHON_THREADS)
#    undef SWIG_PYTHON_THREADS
#  endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
#    define SWIG_PYTHON_USE_GIL
#  endif
#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
#      if PY_VERSION_HEX < 0x03070000
#        define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
#      else
#        define SWIG_PYTHON_INITIALIZE_THREADS
#      endif
#    endif
#    ifdef __cplusplus /* C++ code */
       class SWIG_Python_Thread_Block {
         bool status;
         PyGILState_STATE state;
       public:
         void end() { if (status) { PyGILState_Release(state); status = false;} }
         SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
         ~SWIG_Python_Thread_Block() { end(); }
       };
       class SWIG_Python_Thread_Allow {
         bool status;
         PyThreadState *save;
       public:
         void end() { if (status) { status = false; PyEval_RestoreThread(save); }}
         SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
         ~SWIG_Python_Thread_Allow() { end(); }
       };
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
#    else /* C code */
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
#    endif
#  else /* Old thread way, not implemented, user must provide it */
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
#      define SWIG_PYTHON_INITIALIZE_THREADS
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
#      define SWIG_PYTHON_THREAD_END_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
#      define SWIG_PYTHON_THREAD_END_ALLOW
#    endif
#  endif
#else /* No thread support */
#  define SWIG_PYTHON_INITIALIZE_THREADS
#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#  define SWIG_PYTHON_THREAD_END_BLOCK
#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#  define SWIG_PYTHON_THREAD_END_ALLOW
#endif

/* -----------------------------------------------------------------------------
 * Python API portion that goes into the runtime
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

/* -----------------------------------------------------------------------------
 * Constant declarations
 * ----------------------------------------------------------------------------- */

/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY  5

/* Constant information structure */
typedef struct swig_const_info {
  int type;
  const char *name;
  long lvalue;
  double dvalue;
  void   *pvalue;
  swig_type_info **ptype;
} swig_const_info;

#ifdef __cplusplus
}
#endif


/* -----------------------------------------------------------------------------
 * pyrun.swg
 *
 * This file contains the runtime support for Python modules
 * and includes code for managing global variables and pointer
 * type checking.
 *
 * ----------------------------------------------------------------------------- */

#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif

#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03050000
# error "This version of SWIG only supports Python 3 >= 3.5"
#endif

/* Common SWIG API */

/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)

#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif

#define SWIG_InternalNewPointerObj(ptr, type, flags)	SWIG_Python_NewPointerObj(NULL, ptr, type, flags)

#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype                                    int

/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)

/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)

/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)

/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)


/* Runtime API */

#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)

#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
#define SWIG_SetErrorMsg                        	SWIG_Python_SetErrorMsg				   
#define SWIG_ErrorType(code)                    	SWIG_Python_ErrorType(code)                        
#define SWIG_Error(code, msg)            		SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
#define SWIG_fail                        		goto fail					   

/* Runtime API implementation */

/* Error manipulation */

SWIGINTERN void 
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
  PyErr_SetObject(errtype, obj);
  SWIG_Py_DECREF(obj);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

SWIGINTERN void 
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  PyErr_SetString(errtype, msg);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)

/* Set a constant value */

#if defined(SWIGPYTHON_BUILTIN)

SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
  PyObject *s = PyString_InternFromString(key);
  PyList_Append(seq, s);
  SWIG_Py_DECREF(s);
}

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  SWIG_Py_DECREF(obj);
  if (public_interface)
    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}

#else

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  SWIG_Py_DECREF(obj);
}

#endif

/* SWIG runtime data Python module */
static PyObject *Swig_runtime_data_module_global = NULL;

/* Create/obtain the single swig_runtime_data module which is used across different SWIG generated modules */
SWIGINTERN PyObject *
SWIG_runtime_data_module(void) {
  if (!Swig_runtime_data_module_global) {
#if (PY_VERSION_HEX >= 0x030d0000) && (!defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030d0000)
    /* free-threading note: the GIL is always enabled when this function is first called
       by SWIG_init, so there's no risk of race conditions */
    Swig_runtime_data_module_global = PyImport_AddModuleRef(SWIG_RUNTIME_MODULE);
#elif PY_VERSION_HEX >= 0x03000000
    Swig_runtime_data_module_global = PyImport_AddModule(SWIG_RUNTIME_MODULE);
    SWIG_Py_XINCREF(Swig_runtime_data_module_global);
#else
    static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
    Swig_runtime_data_module_global = Py_InitModule(SWIG_RUNTIME_MODULE, swig_empty_runtime_method_table);
    SWIG_Py_XINCREF(Swig_runtime_data_module_global);
#endif
  }
  assert(Swig_runtime_data_module_global);
  return Swig_runtime_data_module_global;
}

/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj, int is_void) {
  if (!result) {
    result = obj;
  } else if (result == Py_None && is_void) {
    SWIG_Py_DECREF(result);
    result = obj;
  } else {
    if (!PyList_Check(result)) {
      PyObject *o2 = result;
      result = PyList_New(1);
      if (result) {
        PyList_SET_ITEM(result, 0, o2);
      } else {
        SWIG_Py_DECREF(obj);
        return o2;
      }
    }
    PyList_Append(result,obj);
    SWIG_Py_DECREF(obj);
  }
  return result;
}

/* Unpack the argument tuple */

SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
  if (!args) {
    if (!min && !max) {
      return 1;
    } else {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
		   name, (min == max ? "" : "at least "), (int)min);
      return 0;
    }
  }  
  if (!PyTuple_Check(args)) {
    if (min <= 1 && max >= 1) {
      Py_ssize_t i;
      objs[0] = args;
      for (i = 1; i < max; ++i) {
	objs[i] = 0;
      }
      return 2;
    }
    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
    return 0;
  } else {
    Py_ssize_t l = PyTuple_GET_SIZE(args);
    if (l < min) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at least "), (int)min, (int)l);
      return 0;
    } else if (l > max) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at most "), (int)max, (int)l);
      return 0;
    } else {
      Py_ssize_t i;
      for (i = 0; i < l; ++i) {
	objs[i] = PyTuple_GET_ITEM(args, i);
      }
      for (; l < max; ++l) {
	objs[l] = 0;
      }
      return i + 1;
    }    
  }
}

SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
  int no_kwargs = 1;
  if (kwargs) {
    assert(PyDict_Check(kwargs));
    if (PyDict_Size(kwargs) > 0) {
      PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
      no_kwargs = 0;
    }
  }
  return no_kwargs;
}

/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);

/*
  Helper for static pointer initialization for both C and C++ code, for example
  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var)  var
#else
#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
#endif

#ifdef __cplusplus
extern "C" {
#endif

/* Python-specific SWIG API */
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
 
/* -----------------------------------------------------------------------------
 * global variable support code.
 * ----------------------------------------------------------------------------- */
 
typedef struct swig_globalvar {   
  char       *name;                  /* Name of global variable */
  PyObject *(*get_attr)(void);       /* Return the current value */
  int       (*set_attr)(PyObject *); /* Set the value */
  struct swig_globalvar *next;
} swig_globalvar;

typedef struct swig_varlinkobject {
  PyObject_HEAD
  swig_globalvar *vars;
} swig_varlinkobject;

SWIGINTERN PyObject *
SwigVarLink_repr(PyObject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_InternFromString("<Swig global variables>");
#else
  return PyString_FromString("<Swig global variables>");
#endif
}

SWIGINTERN PyObject *
SwigVarLink_str(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
#if PY_VERSION_HEX >= 0x03000000
  PyObject *str = PyUnicode_InternFromString("(");
  PyObject *tail;
  PyObject *joined;
  swig_globalvar *var;
  for (var = v->vars; var; var=var->next) {
    tail = PyUnicode_FromString(var->name);
    joined = PyUnicode_Concat(str, tail);
    SWIG_Py_DECREF(str);
    SWIG_Py_DECREF(tail);
    str = joined;
    if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        SWIG_Py_DECREF(str);
        SWIG_Py_DECREF(tail);
        str = joined;
    }
  }
  tail = PyUnicode_InternFromString(")");
  joined = PyUnicode_Concat(str, tail);
  SWIG_Py_DECREF(str);
  SWIG_Py_DECREF(tail);
  str = joined;
#else
  PyObject *str = PyString_FromString("(");
  swig_globalvar *var;
  for (var = v->vars; var; var=var->next) {
    PyString_ConcatAndDel(&str,PyString_FromString(var->name));
    if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
  }
  PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
  return str;
}

SWIGINTERN void
SwigVarLink_dealloc(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  swig_globalvar *var = v->vars;
  while (var) {
    swig_globalvar *n = var->next;
    free(var->name);
    free(var);
    var = n;
  }
}

SWIGINTERN PyObject *
SwigVarLink_getattr(PyObject *o, char *n) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  PyObject *res = NULL;
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      res = (*var->get_attr)();
      break;
    }
    var = var->next;
  }
  if (res == NULL && !PyErr_Occurred()) {
    PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
  }
  return res;
}

SWIGINTERN int
SwigVarLink_setattr(PyObject *o, char *n, PyObject *p) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  int res = 1;
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      res = (*var->set_attr)(p);
      break;
    }
    var = var->next;
  }
  if (res == 1 && !PyErr_Occurred()) {
    PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
  }
  return res;
}

SWIGINTERN PyTypeObject*
SwigVarLink_TypeOnce(void) {
  static char SwigVarLink_doc[] = "Swig variable link object";
#ifndef SWIG_HEAPTYPES
  static PyTypeObject varlink_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                  /* ob_size */
#endif
      SWIG_RUNTIME_MODULE ".SwigVarLink", /* tp_name */
      sizeof(swig_varlinkobject),         /* tp_basicsize */
      0,                                  /* tp_itemsize */
      (destructor) SwigVarLink_dealloc,   /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                       /* tp_print */
#else
      (Py_ssize_t)0,                      /* tp_vectorcall_offset */
#endif
      (getattrfunc) SwigVarLink_getattr,  /* tp_getattr */
      (setattrfunc) SwigVarLink_setattr,  /* tp_setattr */
      0,                                  /* tp_compare */
      (reprfunc) SwigVarLink_repr,        /* tp_repr */
      0,                                  /* tp_as_number */
      0,                                  /* tp_as_sequence */
      0,                                  /* tp_as_mapping */
      0,                                  /* tp_hash */
      0,                                  /* tp_call */
      (reprfunc) SwigVarLink_str,         /* tp_str */
      0,                                  /* tp_getattro */
      0,                                  /* tp_setattro */
      0,                                  /* tp_as_buffer */
      0,                                  /* tp_flags */
      SwigVarLink_doc,                    /* tp_doc */
      0,                                  /* tp_traverse */
      0,                                  /* tp_clear */
      0,                                  /* tp_richcompare */
      0,                                  /* tp_weaklistoffset */
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
      0,                                  /* tp_del */
      0,                                  /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                  /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                  /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                  /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                  /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                  /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
      0,                                  /* tp_allocs */
      0,                                  /* tp_frees */
      0,                                  /* tp_maxalloc */
      0,                                  /* tp_prev */
      0                                   /* tp_next */
#endif
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    varlink_type = tmp;
    type_init = 1;
    if (PyType_Ready(&varlink_type) < 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigVarLink", (PyObject *)&varlink_type) == 0)
      SWIG_Py_INCREF((PyObject *)&varlink_type);
  }
  return &varlink_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigVarLink_dealloc },
    { Py_tp_repr, (void *)SwigVarLink_repr },
    { Py_tp_getattr, (void *)SwigVarLink_getattr },
    { Py_tp_setattr, (void *)SwigVarLink_setattr },
    { Py_tp_str, (void *)SwigVarLink_str },
    { Py_tp_doc, (void *)SwigVarLink_doc },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigVarLink",
    sizeof(swig_varlinkobject),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigVarLink", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#endif
}

SWIGRUNTIME PyTypeObject*
SwigVarLink_Type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigVarLink_TypeOnce();
  return type;
}

/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
  swig_varlinkobject *result = PyObject_New(swig_varlinkobject, SwigVarLink_Type());
  if (result) {
    result->vars = 0;
  }
  return ((PyObject*) result);
}

SWIGINTERN void 
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
  swig_varlinkobject *v = (swig_varlinkobject *) p;
  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
  if (gv) {
    size_t size = strlen(name)+1;
    gv->name = (char *)malloc(size);
    if (gv->name) {
      memcpy(gv->name, name, size);
      gv->get_attr = get_attr;
      gv->set_attr = set_attr;
      gv->next = v->vars;
    }
  }
  v->vars = gv;
}


static PyObject *Swig_Globals_global = NULL;
  
SWIGINTERN PyObject *
SWIG_globals(void) {
  if (Swig_Globals_global == NULL) {
    Swig_Globals_global = SWIG_newvarlink();
  }
  return Swig_Globals_global;
}

#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------
 * Pointer declarations
 * ----------------------------------------------------------------------------- */

/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)

#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)

#define SWIG_BUILTIN_TP_INIT	    (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT	    (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)

#ifdef __cplusplus
extern "C" {
#endif

/* The python void return value */

SWIGRUNTIMEINLINE PyObject * 
SWIG_Py_Void(void)
{
  PyObject *none = Py_None;
  SWIG_Py_INCREF(none);
  return none;
}

/* SwigPyClientData */

typedef struct {
  PyObject *klass;
  PyObject *newraw;
  PyObject *newargs;
  PyObject *destroy;
  int delargs;
  int implicitconv;
  PyTypeObject *pytype;
} SwigPyClientData;

SWIGRUNTIMEINLINE int 
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
  int fail = data ? data->implicitconv : 0;
  if (fail)
    PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
  return fail;
}

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
  PyObject *klass = data ? data->klass : 0;
  return (klass ? klass : PyExc_RuntimeError);
}


SWIGRUNTIME SwigPyClientData * 
SwigPyClientData_New(PyObject* obj)
{
  if (!obj) {
    return 0;
  } else {
    SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
    /* the klass element */
    data->klass = obj;
    SWIG_Py_INCREF(data->klass);
    /* the newraw method and newargs arguments used to create a new raw instance */
    if (PyClass_Check(obj)) {
      data->newraw = 0;
      SWIG_Py_INCREF(obj);
      data->newargs = obj;
    } else {
      data->newraw = PyObject_GetAttrString(data->klass, "__new__");
      if (data->newraw) {
        data->newargs = PyTuple_New(1);
        if (data->newargs) {
          SWIG_Py_INCREF(obj);
          PyTuple_SET_ITEM(data->newargs, 0, obj);
        } else {
          SWIG_Py_DECREF(data->newraw);
          SWIG_Py_DECREF(data->klass);
          free(data);
          return 0;
        }
      } else {
        SWIG_Py_INCREF(obj);
        data->newargs = obj;
      }
    }
    /* the destroy method, aka as the C++ delete method */
    data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
    if (PyErr_Occurred()) {
      PyErr_Clear();
      data->destroy = 0;
    }
    if (data->destroy) {
      data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
    } else {
      data->delargs = 0;
    }
    data->implicitconv = 0;
    data->pytype = 0;
    return data;
  }
}

SWIGRUNTIME void 
SwigPyClientData_Del(SwigPyClientData *data)
{
  SWIG_Py_XDECREF(data->klass);
  SWIG_Py_XDECREF(data->newraw);
  SWIG_Py_XDECREF(data->newargs);
  SWIG_Py_XDECREF(data->destroy);
  free(data);
}

/* =============== SwigPyObject =====================*/

typedef struct {
  PyObject_HEAD
  void *ptr;
  swig_type_info *ty;
  int own;
  PyObject *next;
  PyObject *swigdict;
  PyObject *weakreflist;
} SwigPyObject;


#ifdef SWIGPYTHON_BUILTIN

SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;

  if (!sobj->swigdict)
    sobj->swigdict = PyDict_New();

  SWIG_Py_XINCREF(sobj->swigdict);
  return sobj->swigdict;
}

#endif

SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
  return PyLong_FromVoidPtr(v->ptr);
}

SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
  PyObject *res = NULL;
  PyObject *args = PyTuple_New(1);
  if (args) {
    PyObject *val = SwigPyObject_long(v);
    if (val) {
      PyObject *ofmt;
      PyTuple_SET_ITEM(args, 0, val);
      ofmt = SWIG_Python_str_FromChar(fmt);
      if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
        res = PyUnicode_Format(ofmt,args);
#else
        res = PyString_Format(ofmt,args);
#endif
        SWIG_Py_DECREF(ofmt);
      }
    }
    SWIG_Py_DECREF(args);
  }
  return res;
}

SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
  return SwigPyObject_format("%o",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
  return SwigPyObject_format("%x",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
  const char *name = SWIG_TypePrettyName(v->ty);
  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
  if (repr && v->next) {
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
    if (nrep) {
# if PY_VERSION_HEX >= 0x03000000
      PyObject *joined = PyUnicode_Concat(repr, nrep);
      SWIG_Py_DECREF(repr);
      SWIG_Py_DECREF(nrep);
      repr = joined;
# else
      PyString_ConcatAndDel(&repr,nrep);
# endif
    } else {
      SWIG_Py_DECREF(repr);
      repr = NULL;
    }
  }
  return repr;
}

/* We need a version taking two PyObject* parameters so it's a valid
 * PyCFunction to use in SwigPyObject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  return SwigPyObject_repr((SwigPyObject*)v);
}

SWIGRUNTIME int
SwigPyObject_compare(PyObject *v, PyObject *w)
{
  /* tp_compare is only called when both objects have the same type, so
   * the casts are guaranteed to be ok. */
  void *i = ((SwigPyObject *)v)->ptr;
  void *j = ((SwigPyObject *)w)->ptr;
  return (i < j) ? -1 : ((i > j) ? 1 : 0);
}

SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *);

/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(PyObject *v, PyObject *w, int op)
{
  PyObject* res = NULL;
  if (!PyErr_Occurred()) {
    /* Per https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_richcompare
     * the first argument is guaranteed to be an instance of SwigPyObject, but the
     * second is not, so we typecheck that one. */
    if ((op != Py_EQ && op != Py_NE) || !SwigPyObject_Check(w)) {
      SWIG_Py_INCREF(Py_NotImplemented);
      return Py_NotImplemented;
    }
    res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
  }
  return res;
}


SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);

#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_Type(void) {
    SwigPyClientData *cd;
    assert(SwigPyObject_stype);
    cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
    assert(cd);
    assert(cd->pytype);
    return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_Type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
  return type;
}
#endif

SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
  PyTypeObject *target_tp = SwigPyObject_Type();
  PyTypeObject *op_type = Py_TYPE(op);
#ifdef SWIGPYTHON_BUILTIN
  /* Only builtin types have SwigPyObject as a base type */
  return PyType_IsSubtype(op_type, target_tp);
#else
  /* Check for an exact match to SwigPyObject */
  if (op_type == target_tp) {
    return 1;
  } else {
    /* Fallback for multiple modules */
#if PY_VERSION_HEX >= 0x03000000
    int cmp;
    PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(op_type);
    if (!tpname)
      return 0;
    cmp = PyUnicode_CompareWithASCIIString(tpname, SWIG_RUNTIME_MODULE ".SwigPyObject");
    SWIG_Py_DECREF(tpname);
    return cmp == 0;
#else
    return strcmp(op_type->tp_name, SWIG_RUNTIME_MODULE ".SwigPyObject") == 0;
#endif
  }
#endif
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);

static PyObject* Swig_Capsule_global = NULL;

SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  PyObject *next = sobj->next;
  if (sobj->own == SWIG_POINTER_OWN) {
    swig_type_info *ty = sobj->ty;
    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    PyObject *destroy = data ? data->destroy : 0;
    if (destroy) {
      /* destroy is always a VARARGS method */
      PyObject *res;

      /* PyObject_CallFunction() has the potential to silently drop
         the active exception.  In cases of unnamed temporary
         variable or where we just finished iterating over a generator
         StopIteration will be active right now, and this needs to
         remain true upon return from SwigPyObject_dealloc.  So save
         and restore. */
      
      PyObject *type = NULL, *value = NULL, *traceback = NULL;
      PyErr_Fetch(&type, &value, &traceback);

      if (data->delargs) {
        /* we need to create a temporary object to carry the destroy operation */
        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
        if (tmp) {
          res = SWIG_Python_CallFunctor(destroy, tmp);
        } else {
          res = 0;
        }
        SWIG_Py_XDECREF(tmp);
      } else {
        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
        PyObject *mself = PyCFunction_GET_SELF(destroy);
        res = ((*meth)(mself, v));
      }
      if (!res)
        PyErr_WriteUnraisable(destroy);

      PyErr_Restore(type, value, traceback);

      SWIG_Py_XDECREF(res);
    } 
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
    else {
      const char *name = SWIG_TypePrettyName(ty);
      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
    }
#endif
    SWIG_Py_XDECREF(Swig_Capsule_global);
  }
  SWIG_Py_XDECREF(next);
  SWIG_Py_XDECREF(sobj->swigdict);
  PyObject_Free(v);
}

SWIGRUNTIME PyObject* 
SwigPyObject_append(PyObject* v, PyObject* next)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (!SwigPyObject_Check(next)) {
    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    return NULL;
  }
  ((SwigPyObject *)next)->next = sobj->next;
  sobj->next = next;
  SWIG_Py_INCREF(next);
  return SWIG_Py_Void();
}

SWIGRUNTIME PyObject* 
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (sobj->next) {    
    SWIG_Py_INCREF(sobj->next);
    return sobj->next;
  } else {
    return SWIG_Py_Void();
  }
}

SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = 0;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = SWIG_POINTER_OWN;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
  PyObject *val = 0;
  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
    return NULL;
  } else {
    SwigPyObject *sobj = (SwigPyObject *)v;
    PyObject *obj = PyBool_FromLong(sobj->own);
    if (val) {
      if (PyObject_IsTrue(val)) {
        SWIG_Py_DECREF(SwigPyObject_acquire(v,args));
      } else {
        SWIG_Py_DECREF(SwigPyObject_disown(v,args));
      }
    } 
    return obj;
  }
}

static PyMethodDef
SwigPyObject_methods[] = {
  {"disown",  SwigPyObject_disown,  METH_NOARGS,  "releases ownership of the pointer"},
  {"acquire", SwigPyObject_acquire, METH_NOARGS,  "acquires ownership of the pointer"},
  {"own",     SwigPyObject_own,     METH_VARARGS, "returns/sets ownership of the pointer"},
  {"append",  SwigPyObject_append,  METH_O,       "appends another 'this' object"},
  {"next",    SwigPyObject_next,    METH_NOARGS,  "returns the next 'this' object"},
  {"__repr__",SwigPyObject_repr2,   METH_NOARGS,  "returns object representation"},
  {0, 0, 0, 0}  
};

SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
  static char SwigPyObject_doc[] = "Swig object holding a C/C++ pointer";
#ifndef SWIG_HEAPTYPES
  static PyNumberMethods SwigPyObject_as_number = {
    (binaryfunc)0, /*nb_add*/
    (binaryfunc)0, /*nb_subtract*/
    (binaryfunc)0, /*nb_multiply*/
    /* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc)0, /*nb_divide*/
#endif
    (binaryfunc)0, /*nb_remainder*/
    (binaryfunc)0, /*nb_divmod*/
    (ternaryfunc)0,/*nb_power*/
    (unaryfunc)0,  /*nb_negative*/
    (unaryfunc)0,  /*nb_positive*/
    (unaryfunc)0,  /*nb_absolute*/
    (inquiry)0,    /*nb_nonzero*/
    0,		   /*nb_invert*/
    0,		   /*nb_lshift*/
    0,		   /*nb_rshift*/
    0,		   /*nb_and*/
    0,		   /*nb_xor*/
    0,		   /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
    0,   /*nb_coerce*/
#endif
    (unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_long, /*nb_long*/
#else
    0, /*nb_reserved*/
#endif
    (unaryfunc)0,                 /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
  };

  static PyTypeObject swigpyobject_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      SWIG_RUNTIME_MODULE ".SwigPyObject",  /* tp_name */
      sizeof(SwigPyObject),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                         /* tp_print */
#else
      (Py_ssize_t)0,                        /* tp_vectorcall_offset */
#endif
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
      0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
      (cmpfunc)SwigPyObject_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyObject_repr,          /* tp_repr */
      &SwigPyObject_as_number,              /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      0,                                    /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      SwigPyObject_doc,                     /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
      offsetof(SwigPyObject, weakreflist),  /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      SwigPyObject_methods,                 /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                    /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                    /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    swigpyobject_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpyobject_type) != 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigPyObject", (PyObject *)&swigpyobject_type) == 0)
      SWIG_Py_INCREF((PyObject *)&swigpyobject_type);
  }
  return &swigpyobject_type;
#else
  static PyMemberDef SwigPyObject_members[] = {
      { (char *)"__dictoffset__", Py_T_PYSSIZET, offsetof(SwigPyObject, swigdict), Py_READONLY, NULL },
      { (char *)"__weaklistoffset__", Py_T_PYSSIZET, offsetof(SwigPyObject, weakreflist), Py_READONLY, NULL },
      { NULL, 0, 0, 0, NULL }
  };
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigPyObject_dealloc },
    { Py_tp_repr, (void *)SwigPyObject_repr },
    { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
    { Py_tp_doc, (void *)SwigPyObject_doc },
    { Py_tp_richcompare, (void *)SwigPyObject_richcompare },
    { Py_tp_methods, (void *)SwigPyObject_methods },
    { Py_nb_int, (void *)SwigPyObject_long },
    { Py_tp_members, (void *)SwigPyObject_members },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigPyObject",
    sizeof(SwigPyObject),
    0,
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
#if !defined(Py_LIMITED_API)
/* While this __dictoffset__ is only used with the builtin wrappers, SwigPyObject ought to be
   identical when created for use by proxy class wrappers in case it is shared across multiple modules. */
#if PY_VERSION_HEX < 0x03090000
    /* Workaround as __dictoffset__ and __weaklistoffset__ above are only supported from python-3.9 */
  if (pytype) {
    ((PyTypeObject *)pytype)->tp_dictoffset = offsetof(SwigPyObject, swigdict);
    ((PyTypeObject *)pytype)->tp_weaklistoffset = offsetof(SwigPyObject, weakreflist);
  }
#endif
#endif
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigPyObject", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#endif
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
  SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_Type());
  if (sobj) {
    sobj->ptr  = ptr;
    sobj->ty   = ty;
    sobj->own  = own;
    sobj->next = 0;
    sobj->swigdict = 0;
    sobj->weakreflist = 0;
    if (own == SWIG_POINTER_OWN) {
      /* Obtain a reference to the Python capsule wrapping the module information, so that the
       * module information is correctly destroyed after all SWIG python objects have been freed
       * by the GC (and corresponding destructors invoked) */
      SWIG_Py_XINCREF(Swig_Capsule_global);
    }
  }
  return (PyObject *)sobj;
}

/* -----------------------------------------------------------------------------
 * Implements a simple Swig Packed type, and use it instead of string
 * ----------------------------------------------------------------------------- */

typedef struct {
  PyObject_HEAD
  void *pack;
  swig_type_info *ty;
  size_t size;
} SwigPyPacked;

SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
  }  
}

SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
    return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromChar(v->ty->name);
  }  
}

SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
  size_t i = v->size;
  size_t j = w->size;
  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
  return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}

SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);

SWIGRUNTIME PyTypeObject*
SwigPyPacked_Type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
  return type;
}

SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
  PyTypeObject *target_tp = SwigPyPacked_Type();
  PyTypeObject *op_type = Py_TYPE(op);
  /* Check for an exact match to SwigPyPacked */
  if (op_type == target_tp) {
    return 1;
  } else {
    /* Fallback for multiple modules */
#if PY_VERSION_HEX >= 0x03000000
    int cmp;
    PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(op_type);
    if (!tpname)
      return 0;
    cmp = PyUnicode_CompareWithASCIIString(tpname, SWIG_RUNTIME_MODULE ".SwigPyPacked");
    SWIG_Py_DECREF(tpname);
    return cmp == 0;
#else
    return strcmp(op_type->tp_name, SWIG_RUNTIME_MODULE ".SwigPyPacked") == 0;
#endif
  }
}

SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
  if (SwigPyPacked_Check(v)) {
    SwigPyPacked *sobj = (SwigPyPacked *) v;
    free(sobj->pack);
  }
  PyObject_Free(v);
}

SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
  static char SwigPyPacked_doc[] = "Swig object holding a C/C++ function pointer";
#ifndef SWIG_HEAPTYPES
  static PyTypeObject swigpypacked_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      SWIG_RUNTIME_MODULE ".SwigPyPacked",  /* tp_name */
      sizeof(SwigPyPacked),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                         /* tp_print */
#else
      (Py_ssize_t)0,                        /* tp_vectorcall_offset */
#endif
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
      0, /* tp_reserved in 3.0.1 */
#else
      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyPacked_repr,          /* tp_repr */
      0,                                    /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      (reprfunc)SwigPyPacked_str,           /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      SwigPyPacked_doc,                     /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      0,                                    /* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      0,                                    /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                    /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                    /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    swigpypacked_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpypacked_type) != 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigPyPacked", (PyObject *)&swigpypacked_type) == 0)
      SWIG_Py_INCREF((PyObject *)&swigpypacked_type);
  }
  return &swigpypacked_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigPyPacked_dealloc },
    { Py_tp_repr, (void *)SwigPyPacked_repr },
    { Py_tp_str, (void *)SwigPyPacked_str },
    { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
    { Py_tp_doc, (void *)SwigPyPacked_doc },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigPyPacked",
    sizeof(SwigPyPacked),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigPyPacked", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#endif
}

SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
  SwigPyPacked *sobj = PyObject_New(SwigPyPacked, SwigPyPacked_Type());
  if (sobj) {
    void *pack = malloc(size);
    if (pack) {
      memcpy(pack, ptr, size);
      sobj->pack = pack;
      sobj->ty   = ty;
      sobj->size = size;
    } else {
      PyObject_Free((PyObject *)sobj);
      sobj = 0;
    }
  }
  return (PyObject *) sobj;
}

SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
  if (SwigPyPacked_Check(obj)) {
    SwigPyPacked *sobj = (SwigPyPacked *)obj;
    if (sobj->size != size) return 0;
    memcpy(ptr, sobj->pack, size);
    return sobj->ty;
  } else {
    return 0;
  }
}

/* -----------------------------------------------------------------------------
 * pointers/data manipulation
 * ----------------------------------------------------------------------------- */

static PyObject *Swig_This_global = NULL;

SWIGRUNTIME PyObject *
SWIG_This(void)
{
  if (Swig_This_global == NULL)
    Swig_This_global = SWIG_Python_str_FromChar("this");
  return Swig_This_global;
}

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX >= 0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS 
#endif

/* Returns a borrowed reference to the 'this' object */
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj) 
{
  PyObject *obj;

  if (SwigPyObject_Check(pyobj))
    return (SwigPyObject *) pyobj;

#ifdef SWIGPYTHON_BUILTIN
  (void)obj;
  if (PyWeakref_CheckProxy(pyobj)) {
#if PY_VERSION_HEX >= 0x030d0000
    if (PyWeakref_GetRef(pyobj, &pyobj) > 0)
      Py_DECREF(pyobj);
    else
      pyobj = NULL;
#else
    pyobj = PyWeakref_GetObject(pyobj);
#endif
    if (pyobj && SwigPyObject_Check(pyobj))
      return (SwigPyObject*) pyobj;
  }
  return NULL;
#else

  obj = 0;

#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
  if (PyInstance_Check(pyobj)) {
    obj = _PyInstance_Lookup(pyobj, SWIG_This());      
  } else {
    PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
    if (dictptr != NULL) {
      PyObject *dict = *dictptr;
      obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
    } else {
      if (PyWeakref_CheckProxy(pyobj)) {
        PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
      }
      obj = PyObject_GetAttr(pyobj, SWIG_This());
      if (obj) {
	SWIG_Py_DECREF(obj);
      } else {
	if (PyErr_Occurred()) PyErr_Clear();
	return 0;
      }
    }
  }
#else
  obj = PyObject_GetAttr(pyobj, SWIG_This());
  if (obj) {
    SWIG_Py_DECREF(obj);
  } else {
    if (PyErr_Occurred()) PyErr_Clear();
    return 0;
  }
#endif
  if (obj && !SwigPyObject_Check(obj)) {
    /* a PyObject is called 'this', try to get the 'real this'
       SwigPyObject from it */ 
    return SWIG_Python_GetSwigThis(obj);
  }
  return (SwigPyObject *)obj;
#endif
}

/* Acquire a pointer value */

SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
  if (own == SWIG_POINTER_OWN) {
    SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
    if (sobj) {
      int oldown = sobj->own;
      sobj->own = own;
      return oldown;
    }
  }
  return 0;
}

/* Convert a pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
  int res;
  SwigPyObject *sobj;
  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;

  if (!obj)
    return SWIG_ERROR;
  if (obj == Py_None && !implicit_conv) {
    if (ptr)
      *ptr = 0;
    return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
  }

  res = SWIG_ERROR;

  sobj = SWIG_Python_GetSwigThis(obj);
  if (own)
    *own = 0;
  while (sobj) {
    void *vptr = sobj->ptr;
    if (ty) {
      swig_type_info *to = sobj->ty;
      if (to == ty) {
        /* no type cast needed */
        if (ptr) *ptr = vptr;
        break;
      } else {
        swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
        if (!tc) {
          sobj = (SwigPyObject *)sobj->next;
        } else {
          if (ptr) {
            int newmemory = 0;
            *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
            if (newmemory == SWIG_CAST_NEW_MEMORY) {
              assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
              if (own)
                *own = *own | SWIG_CAST_NEW_MEMORY;
            }
          }
          break;
        }
      }
    } else {
      if (ptr) *ptr = vptr;
      break;
    }
  }
  if (sobj) {
    if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
      res = SWIG_ERROR_RELEASE_NOT_OWNED;
    } else {
      if (own)
        *own = *own | sobj->own;
      if (flags & SWIG_POINTER_DISOWN) {
        sobj->own = 0;
      }
      if (flags & SWIG_POINTER_CLEAR) {
        sobj->ptr = 0;
      }
      res = SWIG_OK;
    }
  } else {
    if (implicit_conv) {
      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
      if (data && !data->implicitconv) {
        PyObject *klass = data->klass;
        if (klass) {
          PyObject *impconv;
          data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
          impconv = SWIG_Python_CallFunctor(klass, obj);
          data->implicitconv = 0;
          if (PyErr_Occurred()) {
            PyErr_Clear();
            impconv = 0;
          }
          if (impconv) {
            SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
            if (iobj) {
              void *vptr;
              res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
              if (SWIG_IsOK(res)) {
                if (ptr) {
                  *ptr = vptr;
                  /* transfer the ownership to 'ptr' */
                  iobj->own = 0;
                  res = SWIG_AddCast(res);
                  res = SWIG_AddNewMask(res);
                } else {
                  res = SWIG_AddCast(res);		    
                }
              }
            }
            SWIG_Py_DECREF(impconv);
          }
        }
      }
      if (!SWIG_IsOK(res) && obj == Py_None) {
        if (ptr)
          *ptr = 0;
        if (PyErr_Occurred())
          PyErr_Clear();
        res = SWIG_OK;
      }
    }
  }
  return res;
}

/* Convert a function ptr value */

SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
  if (!PyCFunction_Check(obj)) {
    return SWIG_ConvertPtr(obj, ptr, ty, 0);
  } else {
    void *vptr = 0;
    swig_cast_info *tc;

    /* here we get the method pointer for callbacks */
#ifndef Py_LIMITED_API
    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
#else
    PyObject* pystr_doc = PyObject_GetAttrString(obj, "__doc__");
    PyObject *bytes = NULL;
    const char *doc = pystr_doc ? SWIG_PyUnicode_AsUTF8AndSize(pystr_doc, NULL, &bytes) : 0;
#endif
    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    if (desc)
      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
#ifdef Py_LIMITED_API
    SWIG_Py_XDECREF(bytes);
    SWIG_Py_XDECREF(pystr_doc);
#endif
    if (!desc)
      return SWIG_ERROR;
    tc = SWIG_TypeCheck(desc,ty);
    if (tc) {
      int newmemory = 0;
      *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
      assert(!newmemory); /* newmemory handling not yet implemented */
    } else {
      return SWIG_ERROR;
    }
    return SWIG_OK;
  }
}

/* Convert a packed pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
  if (!to) return SWIG_ERROR;
  if (ty) {
    if (to != ty) {
      /* check type cast? */
      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
      if (!tc) return SWIG_ERROR;
    }
  }
  return SWIG_OK;
}  

/* -----------------------------------------------------------------------------
 * Create a new pointer object
 * ----------------------------------------------------------------------------- */

/*
  Create a new instance object, without calling __init__, and set the
  'this' attribute.
*/

SWIGRUNTIME PyObject* 
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
  PyObject *inst = 0;
  PyObject *newraw = data->newraw;
  if (newraw) {
    inst = PyObject_Call(newraw, data->newargs, NULL);
    if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
      PyObject **dictptr = _PyObject_GetDictPtr(inst);
      if (dictptr != NULL) {
        PyObject *dict = *dictptr;
        if (dict == NULL) {
          dict = PyDict_New();
          *dictptr = dict;
        }
        if (dict) {
          PyDict_SetItem(dict, SWIG_This(), swig_this);
        } else{
          SWIG_Py_DECREF(inst);
          inst = 0;
        }
      }
#else
      if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
        SWIG_Py_DECREF(inst);
        inst = 0;
      }
#endif
    }
  } else {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *empty_args = PyTuple_New(0);
    if (empty_args) {
      PyObject *empty_kwargs = PyDict_New();
      if (empty_kwargs) {
#ifndef Py_LIMITED_API
        newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new;
#else
        newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new);
#endif
        inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
        SWIG_Py_DECREF(empty_kwargs);
        if (inst) {
          if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
            SWIG_Py_DECREF(inst);
            inst = 0;
          } else {
            PyType_Modified(Py_TYPE(inst));
          }
        }
      }
      SWIG_Py_DECREF(empty_args);
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      SWIG_Py_DECREF(dict);
    }
#endif
  }
  return inst;
}

SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
  PyObject **dictptr = _PyObject_GetDictPtr(inst);
  if (dictptr != NULL) {
    PyObject *dict = *dictptr;
    if (dict == NULL) {
      dict = PyDict_New();
      *dictptr = dict;
    }
    if (dict) {
      return PyDict_SetItem(dict, SWIG_This(), swig_this);
    } else{
      return -1;
    }
  }
#endif
  return PyObject_SetAttr(inst, SWIG_This(), swig_this);
} 


SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
  PyObject *obj[2];
  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
    return NULL;
  } else {
    SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
    if (sthis) {
      SWIG_Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
    } else {
      if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
        return NULL;
    }
    return SWIG_Py_Void();
  }
}

/* Create a new pointer object */

SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
  SwigPyClientData *clientdata;
  PyObject * robj;
  int own;

  if (!ptr)
    return SWIG_Py_Void();

  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
  if (clientdata && clientdata->pytype) {
    SwigPyObject *newobj;
    if (flags & SWIG_BUILTIN_TP_INIT) {
      newobj = (SwigPyObject*) self;
      if (newobj->ptr) {
#ifndef Py_LIMITED_API
        allocfunc alloc = clientdata->pytype->tp_alloc;
#else
        allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc);
#endif
        PyObject *next_self = alloc(clientdata->pytype, 0);
        while (newobj->next)
	  newobj = (SwigPyObject *) newobj->next;
        newobj->next = next_self;
        newobj = (SwigPyObject *)next_self;
        newobj->swigdict = 0;
        newobj->weakreflist = 0;
      }
    } else {
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
      if (newobj) {
        newobj->swigdict = 0;
        newobj->weakreflist = 0;
      }
    }
    if (newobj) {
      newobj->ptr = ptr;
      newobj->ty = type;
      newobj->own = own;
      newobj->next = 0;
      return (PyObject*) newobj;
    }
    return SWIG_Py_Void();
  }

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

  robj = SwigPyObject_New(ptr, type, own);
  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
    PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
    SWIG_Py_DECREF(robj);
    robj = inst;
  }
  return robj;
}

/* Create a new packed object */

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}

/* -----------------------------------------------------------------------------*
 *  Get type list 
 * -----------------------------------------------------------------------------*/

#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif

static PyObject *Swig_TypeCache_global = NULL;

/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
  if (Swig_TypeCache_global == NULL) {
    Swig_TypeCache_global = PyDict_New();
  }
  return Swig_TypeCache_global;
}

SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
#ifdef SWIG_LINK_RUNTIME
  static void *type_pointer = (void *)0;
  /* first check if module already created */
  if (!type_pointer) {
    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
  }
#else
  void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
  if (PyErr_Occurred()) {
    PyErr_Clear();
    type_pointer = (void *)0;
  }
#endif
  return (swig_module_info *) type_pointer;
}


#if defined(SWIG_REFCNT_DEBUG)
#define SWIG_PYOBJ_REFCNT(OBJ) fprintf(stdout, "" #OBJ " count %ld\n", (OBJ ? Py_REFCNT(OBJ) : 0))
#else
#define SWIG_PYOBJ_REFCNT(OBJ)
#endif

static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */

SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
  swig_type_info **types = swig_module->types;
  size_t i;
  if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */
    return;
  for (i = 0; i < swig_module->size; ++i) {
    swig_type_info *ty = types[i];
    if (ty->owndata) {
      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
      ty->clientdata = 0;
      if (data) SwigPyClientData_Del(data);
    }
  }
  SWIG_PYOBJ_REFCNT(Swig_This_global);
  SWIG_Py_XDECREF(Swig_This_global);
  Swig_This_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_Globals_global);
  SWIG_Py_XDECREF(Swig_Globals_global);
  Swig_Globals_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_TypeCache_global);
  SWIG_Py_XDECREF(Swig_TypeCache_global);
  Swig_TypeCache_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_Capsule_global);
  Swig_Capsule_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_runtime_data_module_global);
  SWIG_Py_XDECREF(Swig_runtime_data_module_global);
  Swig_runtime_data_module_global = NULL;
}

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && runtime_data_module) {
    if (PyModule_AddObject(runtime_data_module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
      ++interpreter_counter;
      Swig_Capsule_global = pointer;
    } else {
      SWIG_Py_DECREF(pointer);
    }
  } else {
    SWIG_Py_XDECREF(pointer);
  }
}

SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
  swig_type_info *descriptor;
  PyObject *cache = SWIG_Python_TypeCache();
  PyObject *obj;
  SWIG_PyDict_GetItemStringRef(cache, type, &obj);
  if (obj) {
    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
  } else {
    swig_module_info *swig_module = SWIG_GetModule(0);
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
      if (obj) PyDict_SetItemString(cache, type, obj);
    }
  }
  SWIG_Py_XDECREF(obj);
  return descriptor;
}

/* 
   For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION  0
#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)

SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{  
  if (PyErr_Occurred()) {
    PyObject *type = 0;
    PyObject *value = 0;
    PyObject *traceback = 0;
    PyErr_Fetch(&type, &value, &traceback);
    if (value) {
      PyObject *old_str = PyObject_Str(value);
      PyObject *bytes = NULL;
      const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
      const char *errmesg = tmp ? tmp : "Invalid error message";
      SWIG_Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, errmesg);
      } else {
	PyErr_Format(type, "%s %s", errmesg, mesg);
      }
      SWIG_Py_XDECREF(bytes);
      SWIG_Py_DECREF(old_str);
    }
    return 1;
  } else {
    return 0;
  }
}
  
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
  if (PyErr_Occurred()) {
    /* add information about failing argument */
    char mesg[256];
    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
    return SWIG_Python_AddErrMesg(mesg, 1);
  } else {
    return 0;
  }
}

SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
  SwigPyObject *v = (SwigPyObject *)self;
  swig_type_info *ty = v ? v->ty : 0;
  return ty ? ty->str : "";
}

/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
  void *result;
  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
    PyErr_Clear();
  }
  return result;
}

#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
  PyTypeObject *tp = Py_TYPE(obj);
  PyObject *descr;
  PyObject *encoded_name;
  descrsetfunc f;
  int res = -1;

# ifdef Py_USING_UNICODE
  if (PyString_Check(name)) {
    name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
    if (!name)
      return -1;
  } else if (!PyUnicode_Check(name))
# else
  if (!PyString_Check(name))
# endif
  {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(Py_TYPE(name));
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%S'", tpname);
    SWIG_Py_DECREF(tpname);
#else
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%s'", Py_TYPE(name)->tp_name);
#endif
    return -1;
  } else {
    SWIG_Py_INCREF(name);
  }

  if (!tp->tp_dict) {
    if (PyType_Ready(tp) != 0)
      goto done;
  }

  descr = _PyType_Lookup(tp, name);
  f = NULL;
  if (descr != NULL)
    f = Py_TYPE(descr)->tp_descr_set;
  if (!f) {
    if (PyString_Check(name)) {
      encoded_name = name;
      SWIG_Py_INCREF(name);
    } else {
      encoded_name = PyUnicode_AsUTF8String(name);
      if (!encoded_name)
        goto done;
    }
#if PY_VERSION_HEX >= 0x03000000
    {
      PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(tp);
      PyErr_Format(PyExc_AttributeError, "'%S' object has no attribute '%s'", tpname, PyString_AsString(encoded_name));
      SWIG_Py_DECREF(tpname);
    }
#else
    PyErr_Format(PyExc_AttributeError, "'%s' object has no attribute '%s'", tp->tp_name, PyString_AsString(encoded_name));
#endif
    SWIG_Py_DECREF(encoded_name);
  } else {
    res = f(descr, obj, value);
  }
  
  done:
  SWIG_Py_DECREF(name);
  return res;
}
#endif


#ifdef __cplusplus
}
#endif



#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 

#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0) 



/* -------- TYPES TABLE (BEGIN) -------- */

#define SWIGTYPE_p_bool swig_types[0]
#define SWIGTYPE_p_char swig_types[1]
#define SWIGTYPE_p_double swig_types[2]
#define SWIGTYPE_p_f_p_void__p_void swig_types[3]
#define SWIGTYPE_p_f_p_void_p_q_const__void_size_t__void swig_types[4]
#define SWIGTYPE_p_int swig_types[5]
#define SWIGTYPE_p_lldb__ConnectionStatus swig_types[6]
#define SWIGTYPE_p_lldb__SBAddress swig_types[7]
#define SWIGTYPE_p_lldb__SBAddressRange swig_types[8]
#define SWIGTYPE_p_lldb__SBAddressRangeList swig_types[9]
#define SWIGTYPE_p_lldb__SBAttachInfo swig_types[10]
#define SWIGTYPE_p_lldb__SBBlock swig_types[11]
#define SWIGTYPE_p_lldb__SBBreakpoint swig_types[12]
#define SWIGTYPE_p_lldb__SBBreakpointList swig_types[13]
#define SWIGTYPE_p_lldb__SBBreakpointLocation swig_types[14]
#define SWIGTYPE_p_lldb__SBBreakpointName swig_types[15]
#define SWIGTYPE_p_lldb__SBBroadcaster swig_types[16]
#define SWIGTYPE_p_lldb__SBCommandInterpreter swig_types[17]
#define SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions swig_types[18]
#define SWIGTYPE_p_lldb__SBCommandReturnObject swig_types[19]
#define SWIGTYPE_p_lldb__SBCommunication swig_types[20]
#define SWIGTYPE_p_lldb__SBCompileUnit swig_types[21]
#define SWIGTYPE_p_lldb__SBData swig_types[22]
#define SWIGTYPE_p_lldb__SBDebugger swig_types[23]
#define SWIGTYPE_p_lldb__SBDeclaration swig_types[24]
#define SWIGTYPE_p_lldb__SBEnvironment swig_types[25]
#define SWIGTYPE_p_lldb__SBError swig_types[26]
#define SWIGTYPE_p_lldb__SBEvent swig_types[27]
#define SWIGTYPE_p_lldb__SBExecutionContext swig_types[28]
#define SWIGTYPE_p_lldb__SBExpressionOptions swig_types[29]
#define SWIGTYPE_p_lldb__SBFile swig_types[30]
#define SWIGTYPE_p_lldb__SBFileSpec swig_types[31]
#define SWIGTYPE_p_lldb__SBFileSpecList swig_types[32]
#define SWIGTYPE_p_lldb__SBFormat swig_types[33]
#define SWIGTYPE_p_lldb__SBFrame swig_types[34]
#define SWIGTYPE_p_lldb__SBFrameList swig_types[35]
#define SWIGTYPE_p_lldb__SBFunction swig_types[36]
#define SWIGTYPE_p_lldb__SBHostOS swig_types[37]
#define SWIGTYPE_p_lldb__SBInstruction swig_types[38]
#define SWIGTYPE_p_lldb__SBInstructionList swig_types[39]
#define SWIGTYPE_p_lldb__SBLanguageRuntime swig_types[40]
#define SWIGTYPE_p_lldb__SBLaunchInfo swig_types[41]
#define SWIGTYPE_p_lldb__SBLineEntry swig_types[42]
#define SWIGTYPE_p_lldb__SBListener swig_types[43]
#define SWIGTYPE_p_lldb__SBMemoryRegionInfo swig_types[44]
#define SWIGTYPE_p_lldb__SBMemoryRegionInfoList swig_types[45]
#define SWIGTYPE_p_lldb__SBModule swig_types[46]
#define SWIGTYPE_p_lldb__SBModuleSpec swig_types[47]
#define SWIGTYPE_p_lldb__SBModuleSpecList swig_types[48]
#define SWIGTYPE_p_lldb__SBMutex swig_types[49]
#define SWIGTYPE_p_lldb__SBPlatform swig_types[50]
#define SWIGTYPE_p_lldb__SBPlatformConnectOptions swig_types[51]
#define SWIGTYPE_p_lldb__SBPlatformShellCommand swig_types[52]
#define SWIGTYPE_p_lldb__SBProcess swig_types[53]
#define SWIGTYPE_p_lldb__SBProcessInfo swig_types[54]
#define SWIGTYPE_p_lldb__SBProcessInfoList swig_types[55]
#define SWIGTYPE_p_lldb__SBProgress swig_types[56]
#define SWIGTYPE_p_lldb__SBQueue swig_types[57]
#define SWIGTYPE_p_lldb__SBQueueItem swig_types[58]
#define SWIGTYPE_p_lldb__SBReproducer swig_types[59]
#define SWIGTYPE_p_lldb__SBSaveCoreOptions swig_types[60]
#define SWIGTYPE_p_lldb__SBScriptObject swig_types[61]
#define SWIGTYPE_p_lldb__SBSection swig_types[62]
#define SWIGTYPE_p_lldb__SBSourceManager swig_types[63]
#define SWIGTYPE_p_lldb__SBStatisticsOptions swig_types[64]
#define SWIGTYPE_p_lldb__SBStream swig_types[65]
#define SWIGTYPE_p_lldb__SBStringList swig_types[66]
#define SWIGTYPE_p_lldb__SBStructuredData swig_types[67]
#define SWIGTYPE_p_lldb__SBSymbol swig_types[68]
#define SWIGTYPE_p_lldb__SBSymbolContext swig_types[69]
#define SWIGTYPE_p_lldb__SBSymbolContextList swig_types[70]
#define SWIGTYPE_p_lldb__SBTarget swig_types[71]
#define SWIGTYPE_p_lldb__SBThread swig_types[72]
#define SWIGTYPE_p_lldb__SBThreadCollection swig_types[73]
#define SWIGTYPE_p_lldb__SBThreadPlan swig_types[74]
#define SWIGTYPE_p_lldb__SBTrace swig_types[75]
#define SWIGTYPE_p_lldb__SBTraceCursor swig_types[76]
#define SWIGTYPE_p_lldb__SBType swig_types[77]
#define SWIGTYPE_p_lldb__SBTypeCategory swig_types[78]
#define SWIGTYPE_p_lldb__SBTypeEnumMember swig_types[79]
#define SWIGTYPE_p_lldb__SBTypeEnumMemberList swig_types[80]
#define SWIGTYPE_p_lldb__SBTypeFilter swig_types[81]
#define SWIGTYPE_p_lldb__SBTypeFormat swig_types[82]
#define SWIGTYPE_p_lldb__SBTypeList swig_types[83]
#define SWIGTYPE_p_lldb__SBTypeMember swig_types[84]
#define SWIGTYPE_p_lldb__SBTypeMemberFunction swig_types[85]
#define SWIGTYPE_p_lldb__SBTypeNameSpecifier swig_types[86]
#define SWIGTYPE_p_lldb__SBTypeStaticField swig_types[87]
#define SWIGTYPE_p_lldb__SBTypeSummary swig_types[88]
#define SWIGTYPE_p_lldb__SBTypeSummaryOptions swig_types[89]
#define SWIGTYPE_p_lldb__SBTypeSynthetic swig_types[90]
#define SWIGTYPE_p_lldb__SBUnixSignals swig_types[91]
#define SWIGTYPE_p_lldb__SBValue swig_types[92]
#define SWIGTYPE_p_lldb__SBValueList swig_types[93]
#define SWIGTYPE_p_lldb__SBVariablesOptions swig_types[94]
#define SWIGTYPE_p_lldb__SBWatchpoint swig_types[95]
#define SWIGTYPE_p_lldb__SBWatchpointOptions swig_types[96]
#define SWIGTYPE_p_long_double swig_types[97]
#define SWIGTYPE_p_long_long swig_types[98]
#define SWIGTYPE_p_p_void swig_types[99]
#define SWIGTYPE_p_pthread_rwlock_t swig_types[100]
#define SWIGTYPE_p_pthread_t swig_types[101]
#define SWIGTYPE_p_short swig_types[102]
#define SWIGTYPE_p_signed_char swig_types[103]
#define SWIGTYPE_p_size_t swig_types[104]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ABI_t swig_types[105]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Baton_t swig_types[106]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Block_t swig_types[107]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointLocation_t swig_types[108]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointPrecondition_t swig_types[109]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointResolver_t swig_types[110]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointSite_t swig_types[111]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Breakpoint_t swig_types[112]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__BroadcasterManager_t swig_types[113]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Broadcaster_t swig_types[114]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__CommandObject_t swig_types[115]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__CompileUnit_t swig_types[116]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Connection_t swig_types[117]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__DataBuffer_t swig_types[118]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__DataExtractor_t swig_types[119]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Debugger_t swig_types[120]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Disassembler_t swig_types[121]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__EventDataStructuredData_t swig_types[122]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__EventData_t swig_types[123]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Event_t swig_types[124]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ExecutionContextRef_t swig_types[125]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ExpressionVariable_t swig_types[126]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__File_t swig_types[127]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__FormatEntity__Entry_t swig_types[128]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__FuncUnwinders_t swig_types[129]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Function_t swig_types[130]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__IOHandler_t swig_types[131]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__IOObject_t swig_types[132]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__IRExecutionUnit_t swig_types[133]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t swig_types[134]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Instruction_t swig_types[135]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t swig_types[136]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__JITLoader_t swig_types[137]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__LanguageRuntime_t swig_types[138]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Listener_t swig_types[139]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__LockableStreamFile_t swig_types[140]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__MemoryHistory_t swig_types[141]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t swig_types[142]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Module_t swig_types[143]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectContainer_t swig_types[144]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t swig_types[145]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectFile_t swig_types[146]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__OperatingSystemInterface_t swig_types[147]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueProperties_t swig_types[148]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValue_t swig_types[149]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Platform_t swig_types[150]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t swig_types[151]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ProcessLaunchInfo_t swig_types[152]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Process_t swig_types[153]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__QueueItem_t swig_types[154]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Queue_t swig_types[155]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__REPL_t swig_types[156]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t swig_types[157]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t swig_types[158]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterContext_t swig_types[159]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterTypeBuilder_t swig_types[160]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegularExpression_t swig_types[161]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptInterpreter_t swig_types[162]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t swig_types[163]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedBreakpointInterface_t swig_types[164]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedFrameInterface_t swig_types[165]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedFrameProviderInterface_t swig_types[166]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedMetadata_t swig_types[167]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedStopHookInterface_t swig_types[168]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t swig_types[169]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t swig_types[170]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedThreadPlanInterface_t swig_types[171]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SearchFilter_t swig_types[172]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SectionLoadList_t swig_types[173]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Section_t swig_types[174]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrameList_t swig_types[175]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t swig_types[176]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrame_t swig_types[177]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StopInfo_t swig_types[178]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StreamFile_t swig_types[179]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Stream_t swig_types[180]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StringSummaryFormat_t swig_types[181]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t swig_types[182]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t swig_types[183]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SymbolFileType_t swig_types[184]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t swig_types[185]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SyntheticChildren_t swig_types[186]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SyntheticFrameProvider_t swig_types[187]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Target_t swig_types[188]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadCollection_t swig_types[189]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t swig_types[190]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlan_t swig_types[191]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t swig_types[192]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Thread_t swig_types[193]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TraceCursor_t swig_types[194]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Trace_t swig_types[195]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t swig_types[196]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t swig_types[197]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeFilterImpl_t swig_types[198]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeFormatImpl_t swig_types[199]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeImpl_t swig_types[200]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t swig_types[201]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t swig_types[202]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t swig_types[203]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t swig_types[204]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSystemClang_t swig_types[205]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSystem_t swig_types[206]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Type_t swig_types[207]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnixSignals_t swig_types[208]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnwindAssembly_t swig_types[209]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnwindPlan_t swig_types[210]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UserExpression_t swig_types[211]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ValueObjectList_t swig_types[212]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ValueObject_t swig_types[213]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Value_t swig_types[214]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__VariableList_t swig_types[215]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Variable_t swig_types[216]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__WatchpointResource_t swig_types[217]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Watchpoint_t swig_types[218]
#define SWIGTYPE_p_std__shared_ptrT_lldb_private__WritableDataBuffer_t swig_types[219]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__AddressRange_t swig_types[220]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__DataExtractor_t swig_types[221]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t swig_types[222]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__DynamicLoader_t swig_types[223]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__File_t swig_types[224]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__JITLoaderList_t swig_types[225]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t swig_types[226]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__OperatingSystem_t swig_types[227]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__ProtocolServer_t swig_types[228]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__ScriptedPlatformInterface_t swig_types[229]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t swig_types[230]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SectionList_t swig_types[231]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SourceManager_t swig_types[232]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t swig_types[233]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__Stream_t swig_types[234]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__StructuredDataImpl_t swig_types[235]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SymbolVendor_t swig_types[236]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SystemRuntime_t swig_types[237]
#define SWIGTYPE_p_std__unique_ptrT_lldb_private__TraceExporter_t swig_types[238]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__BreakpointLocation_t swig_types[239]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Breakpoint_t swig_types[240]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__BroadcasterManager_t swig_types[241]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Debugger_t swig_types[242]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Listener_t swig_types[243]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Module_t swig_types[244]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t swig_types[245]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__OptionValue_t swig_types[246]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Process_t swig_types[247]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Queue_t swig_types[248]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Section_t swig_types[249]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__StackFrameList_t swig_types[250]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__StackFrame_t swig_types[251]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t swig_types[252]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Target_t swig_types[253]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__ThreadPlan_t swig_types[254]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Thread_t swig_types[255]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__TypeSystem_t swig_types[256]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Type_t swig_types[257]
#define SWIGTYPE_p_std__weak_ptrT_lldb_private__UnixSignals_t swig_types[258]
#define SWIGTYPE_p_unsigned_char swig_types[259]
#define SWIGTYPE_p_unsigned_int swig_types[260]
#define SWIGTYPE_p_unsigned_long_long swig_types[261]
#define SWIGTYPE_p_unsigned_short swig_types[262]
#define SWIGTYPE_p_void swig_types[263]
static swig_type_info *swig_types[265];
static swig_module_info swig_module = {swig_types, 264, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

/* -------- TYPES TABLE (END) -------- */

#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery

/*-----------------------------------------------
              @(target):= _lldb.so
  ------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_init    PyInit__lldb

#else
#  define SWIG_init    init_lldb

#endif

#ifdef __cplusplus
#include <utility>
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigSmartPointer {
    T *ptr;
    SwigSmartPointer(T *p) : ptr(p) { }
    ~SwigSmartPointer() { delete ptr; }
    SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
    void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; }
#if __cplusplus >=201103L
  SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; }
  operator T&&() const { return std::move(*pointer.ptr); }
#else
  operator T&() const { return *pointer.ptr; }
#endif
  T *operator&() const { return pointer.ptr; }
  static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
};

/*
 * SwigValueInit() is a generic initialisation solution as the following approach:
 * 
 *       T c_result = T();
 * 
 * doesn't compile for all types for example:
 * 
 *       unsigned int c_result = unsigned int();
 */
template <typename T> T SwigValueInit() {
  return T();
}

#if __cplusplus >=201103L
# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
#else
# define SWIG_STD_MOVE(OBJ) OBJ
#endif

#endif

#if defined(__cplusplus) && (__cplusplus >=201103L)
# define SWIG_OVERRIDE override
#else
# define SWIG_OVERRIDE
#endif



#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 


#include <stdexcept>


namespace swig {
  class SwigPtr_PyObject {
  protected:
    PyObject *_obj;

  public:
    SwigPtr_PyObject() :_obj(0)
    {
    }

    SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_Py_XINCREF(_obj);
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
    {
      if (initial_ref) {
        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        SWIG_Py_XINCREF(_obj);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }
    
    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_Py_XINCREF(item._obj);
      SWIG_Py_XDECREF(_obj);
      _obj = item._obj;
      SWIG_PYTHON_THREAD_END_BLOCK;
      return *this;      
    }
    
    ~SwigPtr_PyObject() 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_Py_XDECREF(_obj);
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    operator PyObject *() const
    {
      return _obj;
    }

    PyObject *operator->() const
    {
      return _obj;
    }
  };
}


namespace swig {
  struct SwigVar_PyObject : SwigPtr_PyObject {
    SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
    
    SwigVar_PyObject & operator = (PyObject* obj)
    {
      SWIG_Py_XDECREF(_obj);
      _obj = obj;
      return *this;      
    }
  };
}


#include <string>


namespace {
template <class T>
T PyLongAsT(PyObject *obj) {
  static_assert(true, "unsupported type");
}

template <> uint64_t PyLongAsT<uint64_t>(PyObject *obj) {
  return static_cast<uint64_t>(PyLong_AsUnsignedLongLong(obj));
}

template <> uint32_t PyLongAsT<uint32_t>(PyObject *obj) {
  return static_cast<uint32_t>(PyLong_AsUnsignedLong(obj));
}

template <> int64_t PyLongAsT<int64_t>(PyObject *obj) {
  return static_cast<int64_t>(PyLong_AsLongLong(obj));
}

template <> int32_t PyLongAsT<int32_t>(PyObject *obj) {
  return static_cast<int32_t>(PyLong_AsLong(obj));
}

template <class T> bool SetNumberFromPyObject(T &number, PyObject *obj) {
  if (PyLong_Check(obj))
    number = PyLongAsT<T>(obj);
  else
    return false;

  return true;
}

template <> bool SetNumberFromPyObject<double>(double &number, PyObject *obj) {
  if (PyFloat_Check(obj)) {
    number = PyFloat_AsDouble(obj);
    return true;
  }

  return false;
}

} // namespace


#include <algorithm>
#include <string>


#include "lldb/lldb-public.h"
#include "lldb/API/LLDB.h"


#include "../source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h"
#include "../source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h"
#include "../bindings/python/python-swigsafecast.swig"
using namespace lldb_private;
using namespace lldb_private::python;
using namespace lldb;


#include <stdint.h>		// Use the C99 official header


SWIGINTERNINLINE PyObject*
  SWIG_From_int  (int value)
{
  return PyInt_FromLong((long) value);
}


SWIGINTERNINLINE PyObject*
  SWIG_From_unsigned_SS_int  (unsigned int value)
{
  return PyInt_FromSize_t((size_t) value);
}


#include <limits.h>
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
#   define LLONG_MAX __LONG_LONG_MAX__
#   define LLONG_MIN (-LLONG_MAX - 1LL)
#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif


#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
#  define SWIG_LONG_LONG_AVAILABLE
#endif


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
#endif


SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
  static swig_type_info* info = 0;
  if (!info) {
    info = SWIG_TypeQuery("_p_char");
  }
  return info;
}


SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  if (carray) {
    if (size > (size_t)PY_SSIZE_T_MAX) {
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
      return pchar_descriptor ? 
	SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    } else {
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
      return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#else
      return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
#endif
#else
      return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#endif
    }
  } else {
    return SWIG_Py_Void();
  }
}


SWIGINTERNINLINE PyObject * 
SWIG_FromCharPtr(const char *cptr)
{ 
  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}


SWIGINTERNINLINE PyObject*
  SWIG_From_bool  (bool value)
{
  return PyBool_FromLong(value ? 1 : 0);
}


SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
  int res = SWIG_TypeError;
  if (PyFloat_Check(obj)) {
    if (val) *val = PyFloat_AsDouble(obj);
    return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
  } else if (PyInt_Check(obj)) {
    if (val) *val = (double) PyInt_AsLong(obj);
    return SWIG_OK;
#endif
  } else if (PyLong_Check(obj)) {
    double v = PyLong_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    double d = PyFloat_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = d;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      long v = PyLong_AsLong(obj);
      if (!PyErr_Occurred()) {
	if (val) *val = v;
	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
      } else {
	PyErr_Clear();
      }
    }
  }
#endif
  return res;
}


#include <errno.h>


#include <float.h>


#include <math.h>


SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
  double x = *d;
  if ((min <= x && x <= max)) {
   double fx, cx, rd;
   errno = 0;
   fx = floor(x);
   cx = ceil(x);
   rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
   if ((errno == EDOM) || (errno == ERANGE)) {
     errno = 0;
   } else {
     double summ, reps, diff;
     if (rd < x) {
       diff = x - rd;
     } else if (rd > x) {
       diff = rd - x;
     } else {
       return 1;
     }
     summ = rd + x;
     reps = diff/summ;
     if (reps < 8*DBL_EPSILON) {
       *d = rd;
       return 1;
     }
   }
  }
  return 0;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    long v = PyInt_AsLong(obj);
    if (v >= 0) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      return SWIG_OverflowError;
    }
  } else
#endif
  if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      // Largest double not larger than ULONG_MAX (not portably calculated easily)
      // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long)
      // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0))
      const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX;
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ulong_max)) {
	if (val) *val = (unsigned long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    unsigned long long v = PyLong_AsUnsignedLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
      if (val) *val = (unsigned long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UINT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned int >(v);
    }
  }  
  return res;
}

SWIGINTERN std::string lldb_SBAddress___repr__(lldb::SBAddress *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }

SWIGINTERNINLINE PyObject *
SWIG_From_std_string  (const std::string& s)
{
  return SWIG_FromCharPtrAndSize(s.data(), s.size());
}


/* Return string from Python obj. NOTE: obj must remain in scope in order
   to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
{
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
  if (PyBytes_Check(obj))
#else
  if (PyUnicode_Check(obj))
#endif
#else  
  if (PyString_Check(obj))
#endif
  {
    char *cstr; Py_ssize_t len;
    PyObject *bytes = NULL;
    int ret = SWIG_OK;
    if (alloc)
      *alloc = SWIG_OLDOBJ;
#if PY_VERSION_HEX >= 0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
      return SWIG_TypeError;
#else
    cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes);
    if (!cstr)
      return SWIG_TypeError;
    /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */
    if (bytes && cptr) {
      if (alloc) {
        cstr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
        *alloc = SWIG_NEWOBJ;
      } else {
        /* alloc must be set in order to clean up allocated memory */
        return SWIG_RuntimeError;
      }
    }
#endif
    if (cptr) *cptr = cstr;
    if (psize) *psize = len + 1;
    SWIG_Py_XDECREF(bytes);
    return ret;
  } else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX < 0x03000000
    if (PyUnicode_Check(obj)) {
      char *cstr; Py_ssize_t len;
      if (!alloc && cptr) {
        return SWIG_RuntimeError;
      }
      obj = PyUnicode_AsUTF8String(obj);
      if (!obj)
        return SWIG_TypeError;
      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
        if (cptr) {
          if (alloc) *alloc = SWIG_NEWOBJ;
          *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
        }
        if (psize) *psize = len + 1;

        SWIG_Py_XDECREF(obj);
        return SWIG_OK;
      } else {
        SWIG_Py_XDECREF(obj);
      }
    }
#endif
#endif

    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      void* vptr = 0;
      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = (char *) vptr;
	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;
	return SWIG_OK;
      }
    }
  }
  return SWIG_TypeError;
}





SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } else
#endif
  if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    long v = PyInt_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      // Largest double not larger than LONG_MAX (not portably calculated easily)
      // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long)
      // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0))
      const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX;
      // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, long_max)) {
	if (val) *val = (long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_bool (PyObject *obj, bool *val)
{
  int r;
  if (!PyBool_Check(obj))
    return SWIG_ERROR;
  r = PyObject_IsTrue(obj);
  if (r == -1)
    return SWIG_ERROR;
  if (val) *val = r ? true : false;
  return SWIG_OK;
}


SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < INT_MIN || v > INT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< int >(v);
    }
  }  
  return res;
}

SWIGINTERN std::string lldb_SBBlock___repr__(lldb::SBBlock *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }

  #define SWIG_From_long   PyInt_FromLong 


SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
}


SWIGINTERNINLINE PyObject *
SWIG_From_size_t  (size_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(size_t) <= sizeof(unsigned long long) */
    return SWIG_From_unsigned_SS_long_SS_long  (static_cast< unsigned long long >(value));
  }
#endif
}

SWIGINTERN std::string lldb_SBBreakpoint___repr__(lldb::SBBreakpoint *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }

SWIGINTERNINLINE int
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    unsigned long long v;
    res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  }
#endif
  return res;
}

SWIGINTERN std::string lldb_SBBreakpointLocation___repr__(lldb::SBBreakpointLocation *self){
    lldb::SBStream stream;
    self->GetDescription (stream, lldb::eDescriptionLevelFull);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBBreakpointName___repr__(lldb::SBBreakpointName *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }

SWIGINTERN int
SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
{ 
  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
  if (SWIG_IsOK(res)) {
    /* special case of single char conversion when we don't need space for NUL */
    if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
    if (csize <= size) {
      if (val) {
	if (csize) memcpy(val, cptr, csize*sizeof(char));
	if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
      }
      if (alloc == SWIG_NEWOBJ) {
	delete[] cptr;
	res = SWIG_DelNewMask(res);
      }      
      return res;
    }
    if (alloc == SWIG_NEWOBJ) delete[] cptr;
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_char (PyObject * obj, char *val)
{    
  int res = SWIG_AsCharArray(obj, val, 1);
  if (!SWIG_IsOK(res)) {
    long v;
    res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
    if (SWIG_IsOK(res)) {
      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
	if (val) *val = static_cast< char >(v);
      } else {
	res = SWIG_OverflowError;
      }
    }
  }
  return res;
}

SWIGINTERN std::string lldb_SBCommandReturnObject___repr__(lldb::SBCommandReturnObject *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN void lldb_SBCommandReturnObject_SetImmediateOutputFile__SWIG_2(lldb::SBCommandReturnObject *self,lldb::FileSP BORROWED,bool transfer_ownership){
        self->SetImmediateOutputFile(BORROWED);
    }
SWIGINTERN void lldb_SBCommandReturnObject_SetImmediateErrorFile__SWIG_2(lldb::SBCommandReturnObject *self,lldb::FileSP BORROWED,bool transfer_ownership){
        self->SetImmediateErrorFile(BORROWED);
    }
SWIGINTERN void lldb_SBCommandReturnObject_Print(lldb::SBCommandReturnObject *self,char const *str){
        self->Printf("%s", str);
    }
SWIGINTERN void lldb_SBCommandReturnObject_write(lldb::SBCommandReturnObject *self,char const *str){
            if (str)
                self->Printf("%s",str);
        }
SWIGINTERN void lldb_SBCommandReturnObject_flush(lldb::SBCommandReturnObject *self){}
SWIGINTERN std::string lldb_SBCompileUnit___repr__(lldb::SBCompileUnit *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }

SWIGINTERNINLINE PyObject *
SWIG_From_unsigned_SS_char  (unsigned char value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UCHAR_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned char >(v);
    }
  }  
  return res;
}


  #define SWIG_From_double   PyFloat_FromDouble 


SWIGINTERNINLINE PyObject *
SWIG_From_float  (float value)
{    
  return SWIG_From_double  (value);
}


SWIGINTERNINLINE PyObject *
SWIG_From_unsigned_SS_short  (unsigned short value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}


SWIGINTERNINLINE PyObject *
SWIG_From_signed_SS_char  (signed char value)
{    
  return SWIG_From_long  (value);
}


SWIGINTERNINLINE PyObject *
SWIG_From_short  (short value)
{    
  return SWIG_From_long  (value);
}


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_long_SS_long  (long long value)
{
  return ((value < LONG_MIN) || (value > LONG_MAX)) ?
    PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
#endif

SWIGINTERN std::string lldb_SBData___repr__(lldb::SBData *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBDebugger___repr__(lldb::SBDebugger *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN lldb::FileSP lldb_SBDebugger_GetInputFileHandle(lldb::SBDebugger *self){
        return self->GetInputFile().GetFile();
    }
SWIGINTERN lldb::FileSP lldb_SBDebugger_GetOutputFileHandle(lldb::SBDebugger *self){
        return self->GetOutputFile().GetFile();
    }
SWIGINTERN lldb::FileSP lldb_SBDebugger_GetErrorFileHandle(lldb::SBDebugger *self){
        return self->GetErrorFile().GetFile();
    }
SWIGINTERN std::string lldb_SBDeclaration___repr__(lldb::SBDeclaration *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBError___repr__(lldb::SBError *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN lldb::SBFile lldb_SBFile_MakeBorrowed(lldb::FileSP BORROWED){
        return lldb::SBFile(BORROWED);
    }
SWIGINTERN lldb::SBFile lldb_SBFile_MakeForcingIOMethods(lldb::FileSP FORCE_IO_METHODS){
        return lldb::SBFile(FORCE_IO_METHODS);
    }
SWIGINTERN lldb::SBFile lldb_SBFile_MakeBorrowedForcingIOMethods(lldb::FileSP BORROWED_FORCE_IO_METHODS){
        return lldb::SBFile(BORROWED_FORCE_IO_METHODS);
    }
SWIGINTERN std::string lldb_SBFileSpec___repr__(lldb::SBFileSpec *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBFileSpecList___repr__(lldb::SBFileSpecList *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBFrame___repr__(lldb::SBFrame *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBFrameList___str__(lldb::SBFrameList *self){
           lldb::SBStream description;
           if (!self->GetDescription(description))
               return std::string("<empty> lldb.SBFrameList()");
           const char *desc = description.GetData();
           size_t desc_len = description.GetSize();
           if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
               --desc_len;
           return std::string(desc, desc_len);
       }
SWIGINTERN std::string lldb_SBFunction___repr__(lldb::SBFunction *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBInstruction___repr__(lldb::SBInstruction *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBInstructionList___repr__(lldb::SBInstructionList *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBLineEntry___repr__(lldb::SBLineEntry *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBMemoryRegionInfo___repr__(lldb::SBMemoryRegionInfo *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBModule___repr__(lldb::SBModule *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBModuleSpec___repr__(lldb::SBModuleSpec *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBModuleSpecList___repr__(lldb::SBModuleSpecList *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBProcess___repr__(lldb::SBProcess *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBSection___repr__(lldb::SBSection *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN void lldb_SBStream_RedirectToFileHandle(lldb::SBStream *self,lldb::FileSP file,bool transfer_fh_ownership){
        self->RedirectToFile(file);
    }
SWIGINTERN void lldb_SBStream_write(lldb::SBStream *self,char const *str){
            if (str)
                self->Printf("%s",str);
        }
SWIGINTERN void lldb_SBStream_flush(lldb::SBStream *self){}

#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    long long v = PyLong_AsLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    long v;
    res = SWIG_AsVal_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    const double mant_min = -mant_max;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
      if (val) *val = (long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif

SWIGINTERN std::string lldb_SBStructuredData___repr__(lldb::SBStructuredData *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBSymbol___repr__(lldb::SBSymbol *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBSymbolContext___repr__(lldb::SBSymbolContext *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBSymbolContextList___repr__(lldb::SBSymbolContextList *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBTarget___repr__(lldb::SBTarget *self){
    lldb::SBStream stream;
    self->GetDescription (stream, lldb::eDescriptionLevelBrief);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBThread___repr__(lldb::SBThread *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBTypeMember___repr__(lldb::SBTypeMember *self){
    lldb::SBStream stream;
    self->GetDescription (stream, lldb::eDescriptionLevelBrief);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBTypeMemberFunction___repr__(lldb::SBTypeMemberFunction *self){
    lldb::SBStream stream;
    self->GetDescription (stream, lldb::eDescriptionLevelBrief);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBType___repr__(lldb::SBType *self){
    lldb::SBStream stream;
    self->GetDescription (stream, lldb::eDescriptionLevelBrief);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBTypeCategory___repr__(lldb::SBTypeCategory *self){
    lldb::SBStream stream;
    self->GetDescription (stream, lldb::eDescriptionLevelBrief);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBTypeEnumMember___repr__(lldb::SBTypeEnumMember *self){
    lldb::SBStream stream;
    self->GetDescription (stream, lldb::eDescriptionLevelBrief);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBTypeFilter___repr__(lldb::SBTypeFilter *self){
    lldb::SBStream stream;
    self->GetDescription (stream, lldb::eDescriptionLevelBrief);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBTypeFormat___repr__(lldb::SBTypeFormat *self){
    lldb::SBStream stream;
    self->GetDescription (stream, lldb::eDescriptionLevelBrief);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBTypeNameSpecifier___repr__(lldb::SBTypeNameSpecifier *self){
    lldb::SBStream stream;
    self->GetDescription (stream, lldb::eDescriptionLevelBrief);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBTypeSummary___repr__(lldb::SBTypeSummary *self){
    lldb::SBStream stream;
    self->GetDescription (stream, lldb::eDescriptionLevelBrief);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBTypeSynthetic___repr__(lldb::SBTypeSynthetic *self){
    lldb::SBStream stream;
    self->GetDescription (stream, lldb::eDescriptionLevelBrief);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBValue___repr__(lldb::SBValue *self){
    lldb::SBStream stream;
    self->GetDescription (stream);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }
SWIGINTERN std::string lldb_SBValueList___str__(lldb::SBValueList *self){
           lldb::SBStream description;
           const size_t n = self->GetSize();
           if (n)
           {
               for (size_t i=0; i<n; ++i)
                   self->GetValueAtIndex(i).GetDescription(description);
           }
           else
           {
               description.Printf("<empty> lldb.SBValueList()");
           }
           const char *desc = description.GetData();
           size_t desc_len = description.GetSize();
           if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
               --desc_len;
           return std::string(desc, desc_len);
       }
SWIGINTERN std::string lldb_SBWatchpoint___repr__(lldb::SBWatchpoint *self){
    lldb::SBStream stream;
    self->GetDescription (stream, lldb::eDescriptionLevelVerbose);
    const char *desc = stream.GetData();
    size_t desc_len = stream.GetSize();
    if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r')) {
      --desc_len;
    }
    return std::string(desc, desc_len);
  }


class PyErr_Cleaner {
public:
  PyErr_Cleaner(bool print = false) : m_print(print) {}

  ~PyErr_Cleaner() {
    if (PyErr_Occurred()) {
      if (m_print && !PyErr_ExceptionMatches(PyExc_SystemExit))
        PyErr_Print();
      PyErr_Clear();
    }
  }

private:
  bool m_print;
};

llvm::Expected<bool> lldb_private::python::SWIGBridge::LLDBSwigPythonBreakpointCallbackFunction(
    const char *python_function_name, const char *session_dictionary_name,
    const lldb::StackFrameSP &frame_sp,
    const lldb::BreakpointLocationSP &bp_loc_sp,
    const lldb_private::StructuredDataImpl &args_impl) {
  using namespace llvm;

  lldb::SBBreakpointLocation sb_bp_loc(bp_loc_sp);

  PyErr_Cleaner py_err_cleaner(true);
  auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
      session_dictionary_name);
  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
      python_function_name, dict);

  unsigned max_positional_args;
  if (auto arg_info = pfunc.GetArgInfo())
    max_positional_args = arg_info.get().max_positional_args;
  else
    return arg_info.takeError();

  PythonObject frame_arg = SWIGBridge::ToSWIGWrapper(frame_sp);
  PythonObject bp_loc_arg = SWIGBridge::ToSWIGWrapper(bp_loc_sp);

  auto result =
      max_positional_args < 4
          ? pfunc.Call(frame_arg, bp_loc_arg, dict)
          : pfunc.Call(frame_arg, bp_loc_arg, SWIGBridge::ToSWIGWrapper(args_impl), dict);

  if (!result)
    return result.takeError();

  // Only False counts as false!
  return result.get().get() != Py_False;
}

// resolve a dotted Python name in the form
// foo.bar.baz.Foobar to an actual Python object
// if pmodule is NULL, the __main__ module will be used
// as the starting point for the search

// This function is called by
// lldb_private::ScriptInterpreterPython::BreakpointCallbackFunction(...) and is
// used when a script command is attached to a breakpoint for execution.

// This function is called by
// lldb_private::ScriptInterpreterPython::WatchpointCallbackFunction(...) and is
// used when a script command is attached to a watchpoint for execution.

bool lldb_private::python::SWIGBridge::LLDBSwigPythonWatchpointCallbackFunction(
    const char *python_function_name, const char *session_dictionary_name,
    const lldb::StackFrameSP &frame_sp, const lldb::WatchpointSP &wp_sp) {

  bool stop_at_watchpoint = true;

  PyErr_Cleaner py_err_cleaner(true);

  auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
      session_dictionary_name);
  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
      python_function_name, dict);

  if (!pfunc.IsAllocated())
    return stop_at_watchpoint;

  PythonObject result =
      pfunc(SWIGBridge::ToSWIGWrapper(frame_sp), SWIGBridge::ToSWIGWrapper(wp_sp), dict);

  if (result.get() == Py_False)
    stop_at_watchpoint = false;

  return stop_at_watchpoint;
}

// This function is called by
// ScriptInterpreterPython::FormatterMatchingCallbackFunction and it's used when
// a data formatter provides the name of a callback to inspect a candidate type
// before considering a match.
bool lldb_private::python::SWIGBridge::LLDBSwigPythonFormatterCallbackFunction(
    const char *python_function_name, const char *session_dictionary_name,
    lldb::TypeImplSP type_impl_sp) {

  PyErr_Cleaner py_err_cleaner(true);

  auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
      session_dictionary_name);
  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
      python_function_name, dict);

  if (!pfunc.IsAllocated())
    return false;

  PythonObject result =
      pfunc(SWIGBridge::ToSWIGWrapper(type_impl_sp), dict);

  // Only if everything goes okay and the function returns True we'll consider
  // it a match.
  return result.get() == Py_True;
}

bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallTypeScript(
    const char *python_function_name, const void *session_dictionary,
    const lldb::ValueObjectSP &valobj_sp, void **pyfunct_wrapper,
    const lldb::TypeSummaryOptionsSP &options_sp, std::string &retval) {

  retval.clear();

  if (!python_function_name || !session_dictionary)
    return false;

  PyObject *pfunc_impl = nullptr;

  if (pyfunct_wrapper && *pyfunct_wrapper
#ifndef Py_LIMITED_API
      && PyFunction_Check(*pyfunct_wrapper)
#endif
      ) {
    pfunc_impl = (PyObject *)(*pyfunct_wrapper);
    if (Py_REFCNT(pfunc_impl) == 1) {
      Py_XDECREF(pfunc_impl);
      pfunc_impl = NULL;
    }
  }

  PyObject *py_dict = (PyObject *)session_dictionary;
  if (!PythonDictionary::Check(py_dict))
    return true;

  PythonDictionary dict(PyRefType::Borrowed, py_dict);

  PyErr_Cleaner pyerr_cleanup(true); // show Python errors

  PythonCallable pfunc(PyRefType::Borrowed, pfunc_impl);

  if (!pfunc.IsAllocated()) {
    pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
        python_function_name, dict);
    if (!pfunc.IsAllocated())
      return false;

    if (pyfunct_wrapper) {
      *pyfunct_wrapper = pfunc.get();
      Py_XINCREF(pfunc.get());
    }
  }

  PythonObject result;
  auto argc = pfunc.GetArgInfo();
  if (!argc) {
    llvm::consumeError(argc.takeError());
    return false;
  }

  PythonObject value_arg = SWIGBridge::ToSWIGWrapper(valobj_sp);

  if (argc.get().max_positional_args < 3)
    result = pfunc(value_arg, dict);
  else
    result = pfunc(value_arg, dict, SWIGBridge::ToSWIGWrapper(*options_sp));

  retval = result.Str().GetString().str();

  return true;
}

PythonObject lldb_private::python::SWIGBridge::LLDBSwigPythonCreateSyntheticProvider(
    const char *python_class_name, const char *session_dictionary_name,
    const lldb::ValueObjectSP &valobj_sp) {
  if (python_class_name == NULL || python_class_name[0] == '\0' ||
      !session_dictionary_name)
    return PythonObject();

  PyErr_Cleaner py_err_cleaner(true);

  auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
      session_dictionary_name);
  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
      python_class_name, dict);

  if (!pfunc.IsAllocated())
    return PythonObject();

  auto sb_value = std::unique_ptr<lldb::SBValue>(new lldb::SBValue(valobj_sp));
  sb_value->SetPreferSyntheticValue(false);

  PythonObject val_arg = SWIGBridge::ToSWIGWrapper(std::move(sb_value));
  if (!val_arg.IsAllocated())
    return PythonObject();

  PythonObject result = pfunc(val_arg, dict);

  if (result.IsAllocated())
    return result;

  return PythonObject();
}

PythonObject lldb_private::python::SWIGBridge::LLDBSwigPythonCreateCommandObject(
    const char *python_class_name, const char *session_dictionary_name,
    lldb::DebuggerSP debugger_sp) {
  if (python_class_name == NULL || python_class_name[0] == '\0' ||
      !session_dictionary_name)
    return PythonObject();

  PyErr_Cleaner py_err_cleaner(true);
  auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
      session_dictionary_name);
  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
      python_class_name, dict);

  if (!pfunc.IsAllocated())
    return PythonObject();

  return pfunc(SWIGBridge::ToSWIGWrapper(std::move(debugger_sp)), dict);
}

// wrapper that calls an optional instance member of an object taking no
// arguments
static PyObject *LLDBSwigPython_CallOptionalMember(
    PyObject * implementor, char *callee_name,
    PyObject *ret_if_not_found = Py_None, bool *was_found = NULL) {
  PyErr_Cleaner py_err_cleaner(false);

  PythonObject self(PyRefType::Borrowed, static_cast<PyObject *>(implementor));
  auto pfunc = self.ResolveName<PythonCallable>(callee_name);

  if (!pfunc.IsAllocated()) {
    if (was_found)
      *was_found = false;
    Py_XINCREF(ret_if_not_found);
    return ret_if_not_found;
  }

  if (was_found)
    *was_found = true;

  PythonObject result = pfunc();
  return result.release();
}

size_t lldb_private::python::SWIGBridge::LLDBSwigPython_CalculateNumChildren(PyObject * implementor,
                                                         uint32_t max) {
  PythonObject self(PyRefType::Borrowed, implementor);
  auto pfunc = self.ResolveName<PythonCallable>("num_children");

  if (!pfunc.IsAllocated())
    return 0;

  auto arg_info = pfunc.GetArgInfo();
  if (!arg_info) {
    llvm::consumeError(arg_info.takeError());
    return 0;
  }

  size_t ret_val;
  if (arg_info.get().max_positional_args < 1)
    ret_val = unwrapOrSetPythonException(As<long long>(pfunc.Call()));
  else
    ret_val = unwrapOrSetPythonException(
        As<long long>(pfunc.Call(PythonInteger(max))));

  if (PyErr_Occurred()) {
    PyErr_Print();
    PyErr_Clear();
    return 0;
  }

  if (arg_info.get().max_positional_args < 1)
    ret_val = std::min(ret_val, static_cast<size_t>(max));

  return ret_val;
}

PyObject *lldb_private::python::SWIGBridge::LLDBSwigPython_GetChildAtIndex(PyObject * implementor,
                                                       uint32_t idx) {
  PyErr_Cleaner py_err_cleaner(true);

  PythonObject self(PyRefType::Borrowed, implementor);
  auto pfunc = self.ResolveName<PythonCallable>("get_child_at_index");

  if (!pfunc.IsAllocated())
    return nullptr;

  PythonObject result = pfunc(PythonInteger(idx));

  if (!result.IsAllocated())
    return nullptr;

  lldb::SBValue *sbvalue_ptr = nullptr;
  if (SWIG_ConvertPtr(result.get(), (void **)&sbvalue_ptr,
                      SWIGTYPE_p_lldb__SBValue, 0) == -1)
    return nullptr;

  if (sbvalue_ptr == nullptr)
    return nullptr;

  return result.release();
}

uint32_t lldb_private::python::SWIGBridge::LLDBSwigPython_GetIndexOfChildWithName(
    PyObject * implementor, const char *child_name) {
  PyErr_Cleaner py_err_cleaner(true);

  PythonObject self(PyRefType::Borrowed, implementor);
  auto pfunc = self.ResolveName<PythonCallable>("get_child_index");

  if (!pfunc.IsAllocated())
    return UINT32_MAX;

  llvm::Expected<PythonObject> result = pfunc.Call(PythonString(child_name));

  long long retval =
      unwrapOrSetPythonException(As<long long>(std::move(result)));

  if (PyErr_Occurred()) {
    PyErr_Clear(); // FIXME print this? do something else
    return UINT32_MAX;
  }

  if (retval >= 0)
    return (uint32_t)retval;

  return UINT32_MAX;
}

bool lldb_private::python::SWIGBridge::LLDBSwigPython_UpdateSynthProviderInstance(PyObject *
                                                              implementor) {
  bool ret_val = false;

  static char callee_name[] = "update";

  PyObject *py_return =
      LLDBSwigPython_CallOptionalMember(implementor, callee_name);

  if (py_return == Py_True)
    ret_val = true;

  Py_XDECREF(py_return);

  return ret_val;
}

bool lldb_private::python::SWIGBridge::LLDBSwigPython_MightHaveChildrenSynthProviderInstance(
    PyObject * implementor) {
  bool ret_val = false;

  static char callee_name[] = "has_children";

  PyObject *py_return =
      LLDBSwigPython_CallOptionalMember(implementor, callee_name, Py_True);

  if (py_return == Py_True)
    ret_val = true;

  Py_XDECREF(py_return);

  return ret_val;
}

PyObject *lldb_private::python::SWIGBridge::LLDBSwigPython_GetValueSynthProviderInstance(
    PyObject * implementor) {
  PyObject *ret_val = nullptr;

  static char callee_name[] = "get_value";

  PyObject *py_return =
      LLDBSwigPython_CallOptionalMember(implementor, callee_name, Py_None);

  if (py_return == Py_None || py_return == nullptr)
    ret_val = nullptr;

  lldb::SBValue *sbvalue_ptr = NULL;

  if (SWIG_ConvertPtr(py_return, (void **)&sbvalue_ptr,
                      SWIGTYPE_p_lldb__SBValue, 0) == -1)
    ret_val = nullptr;
  else if (sbvalue_ptr == NULL)
    ret_val = nullptr;
  else
    ret_val = py_return;

  Py_XDECREF(py_return);
  return ret_val;
}

void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBData(PyObject * data) {
  lldb::SBData *sb_ptr = nullptr;

  int valid_cast =
      SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBData, 0);

  if (valid_cast == -1)
    return NULL;

  return sb_ptr;
}

void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBBreakpoint(PyObject * data) {
  lldb::SBBreakpoint *sb_ptr = nullptr;

  int valid_cast =
      SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBBreakpoint, 0);

  if (valid_cast == -1)
    return NULL;

  return sb_ptr;
}

void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBThread(PyObject * data) {
  lldb::SBThread *sb_ptr = nullptr;

  int valid_cast =
      SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBThread, 0);

  if (valid_cast == -1)
    return NULL;

  return sb_ptr;
}

void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBFrame(PyObject * data) {
  lldb::SBFrame *sb_ptr = nullptr;

  int valid_cast =
      SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBFrame, 0);

  if (valid_cast == -1)
    return NULL;

  return sb_ptr;
}

void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBBreakpointLocation(PyObject * data) {
  lldb::SBBreakpointLocation *sb_ptr = nullptr;

  int valid_cast =
      SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBBreakpointLocation, 0);

  if (valid_cast == -1)
    return NULL;

  return sb_ptr;
}

void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBAttachInfo(PyObject * data) {
  lldb::SBAttachInfo *sb_ptr = nullptr;

  int valid_cast =
      SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBAttachInfo, 0);

  if (valid_cast == -1)
    return NULL;

  return sb_ptr;
}

void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBLaunchInfo(PyObject * data) {
  lldb::SBLaunchInfo *sb_ptr = nullptr;

  int valid_cast =
      SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBLaunchInfo, 0);

  if (valid_cast == -1)
    return NULL;

  return sb_ptr;
}

void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBError(PyObject * data) {
  lldb::SBError *sb_ptr = nullptr;

  int valid_cast =
      SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBError, 0);

  if (valid_cast == -1)
    return NULL;

  return sb_ptr;
}

void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBEvent(PyObject * data) {
  lldb::SBEvent *sb_ptr = nullptr;

  int valid_cast =
      SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBEvent, 0);

  if (valid_cast == -1)
    return NULL;

  return sb_ptr;
}

void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBStream(PyObject * data) {
  lldb::SBStream *sb_ptr = nullptr;

  int valid_cast =
      SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBStream, 0);

  if (valid_cast == -1)
    return NULL;

  return sb_ptr;
}

void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBSymbolContext(PyObject * data) {
  lldb::SBSymbolContext *sb_ptr = nullptr;

  int valid_cast =
      SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBSymbolContext, 0);

  if (valid_cast == -1)
    return NULL;

  return sb_ptr;
}

void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBValue(PyObject * data) {
  lldb::SBValue *sb_ptr = NULL;

  int valid_cast =
      SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBValue, 0);

  if (valid_cast == -1)
    return NULL;

  return sb_ptr;
}

void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBValueList(PyObject * data) {
  lldb::SBValueList *sb_ptr = NULL;

  int valid_cast =
      SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBValueList, 0);

  if (valid_cast == -1)
    return NULL;

  return sb_ptr;
}

void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(PyObject *
                                                                    data) {
  lldb::SBMemoryRegionInfo *sb_ptr = NULL;

  int valid_cast = SWIG_ConvertPtr(data, (void **)&sb_ptr,
                                   SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0);

  if (valid_cast == -1)
    return NULL;

  return sb_ptr;
}

void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBExecutionContext(PyObject *
                                                                    data) {
  lldb::SBExecutionContext *sb_ptr = NULL;

  int valid_cast = SWIG_ConvertPtr(data, (void **)&sb_ptr,
                                   SWIGTYPE_p_lldb__SBExecutionContext, 0);

  if (valid_cast == -1)
    return NULL;

  return sb_ptr;
}

void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBFrameList(PyObject *data) {
  lldb::SBFrameList *sb_ptr = NULL;

  int valid_cast = SWIG_ConvertPtr(data, (void **)&sb_ptr,
                                   SWIGTYPE_p_lldb__SBFrameList, 0);

  if (valid_cast == -1)
    return NULL;

  return sb_ptr;
}

bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallCommand(
    const char *python_function_name, const char *session_dictionary_name,
    lldb::DebuggerSP debugger, const char *args,
    lldb_private::CommandReturnObject &cmd_retobj,
    lldb::ExecutionContextRefSP exe_ctx_ref_sp) {

  PyErr_Cleaner py_err_cleaner(true);
  auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
      session_dictionary_name);
  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
      python_function_name, dict);

  if (!pfunc.IsAllocated())
    return false;

  auto argc = pfunc.GetArgInfo();
  if (!argc) {
    llvm::consumeError(argc.takeError());
    return false;
  }
  PythonObject debugger_arg = SWIGBridge::ToSWIGWrapper(std::move(debugger));
  auto cmd_retobj_arg = SWIGBridge::ToSWIGWrapper(cmd_retobj);

  if (argc.get().max_positional_args < 5u)
    pfunc(debugger_arg, PythonString(args), cmd_retobj_arg.obj(), dict);
  else
    pfunc(debugger_arg, PythonString(args),
          SWIGBridge::ToSWIGWrapper(std::move(exe_ctx_ref_sp)), cmd_retobj_arg.obj(), dict);

  return true;
}

bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallCommandObject(
    PyObject *implementor, lldb::DebuggerSP debugger, const char *args,
    lldb_private::CommandReturnObject &cmd_retobj,
    lldb::ExecutionContextRefSP exe_ctx_ref_sp) {

  PyErr_Cleaner py_err_cleaner(true);

  PythonObject self(PyRefType::Borrowed, implementor);
  auto pfunc = self.ResolveName<PythonCallable>("__call__");

  if (!pfunc.IsAllocated())
    return false;

  auto cmd_retobj_arg = SWIGBridge::ToSWIGWrapper(cmd_retobj);

  pfunc(SWIGBridge::ToSWIGWrapper(std::move(debugger)), PythonString(args),
        SWIGBridge::ToSWIGWrapper(exe_ctx_ref_sp), cmd_retobj_arg.obj());

  return true;
}

std::optional<std::string>
lldb_private::python::SWIGBridge::LLDBSwigPythonGetRepeatCommandForScriptedCommand(PyObject *implementor,
                                               std::string &command) {
  PyErr_Cleaner py_err_cleaner(true);

  PythonObject self(PyRefType::Borrowed, implementor);
  auto pfunc = self.ResolveName<PythonCallable>("get_repeat_command");
  // If not implemented, repeat the exact command.
  if (!pfunc.IsAllocated())
    return std::nullopt;

  PythonString command_str(command);
  PythonObject result = pfunc(command_str);

  // A return of None is the equivalent of nullopt - means repeat
  // the command as is:
  if (result.IsNone())
    return std::nullopt;

  return result.Str().GetString().str();
}

StructuredData::DictionarySP
lldb_private::python::SWIGBridge::LLDBSwigPythonHandleArgumentCompletionForScriptedCommand(PyObject *implementor,
    std::vector<llvm::StringRef> &args_vec, size_t args_pos, size_t pos_in_arg) {

  PyErr_Cleaner py_err_cleaner(true);

  PythonObject self(PyRefType::Borrowed, implementor);
  auto pfunc = self.ResolveName<PythonCallable>("handle_argument_completion");
  // If this isn't implemented, return an empty dict to signal falling back to default completion:
  if (!pfunc.IsAllocated())
    return {};

  PythonList args_list(PyInitialValue::Empty);
  for (auto elem : args_vec)
    args_list.AppendItem(PythonString(elem));

  PythonObject result = pfunc(args_list, PythonInteger(args_pos), PythonInteger(pos_in_arg));
  // Returning None means do the ordinary completion
  if (result.IsNone())
    return {};

  // Convert the return dictionary to a DictionarySP.
  StructuredData::ObjectSP result_obj_sp = result.CreateStructuredObject();
  if (!result_obj_sp)
    return {};

  StructuredData::DictionarySP dict_sp(new StructuredData::Dictionary(result_obj_sp));
  if (dict_sp->GetType() == lldb::eStructuredDataTypeInvalid)
    return {};
  return dict_sp;
}

StructuredData::DictionarySP
lldb_private::python::SWIGBridge::LLDBSwigPythonHandleOptionArgumentCompletionForScriptedCommand(PyObject *implementor,
    llvm::StringRef &long_option, size_t pos_in_arg) {

  PyErr_Cleaner py_err_cleaner(true);

  PythonObject self(PyRefType::Borrowed, implementor);
  auto pfunc = self.ResolveName<PythonCallable>("handle_option_argument_completion");
  // If this isn't implemented, return an empty dict to signal falling back to default completion:
  if (!pfunc.IsAllocated())
    return {};

  PythonObject result = pfunc(PythonString(long_option), PythonInteger(pos_in_arg));
  // Returning None means do the ordinary completion
  if (result.IsNone())
    return {};

  // Returning a boolean:
  // True means the completion was handled, but there were no completions
  // False means that the completion was not handled, again, do the ordinary completion:
  if (result.GetObjectType() == PyObjectType::Boolean) {
    if (!result.IsTrue())
      return {};
    // Make up a completion dictionary with the right element:
    StructuredData::DictionarySP dict_sp(new StructuredData::Dictionary());
    dict_sp->AddBooleanItem("no-completion", true);
    return dict_sp;
  }


  // Convert the return dictionary to a DictionarySP.
  StructuredData::ObjectSP result_obj_sp = result.CreateStructuredObject();
  if (!result_obj_sp)
    return {};

  StructuredData::DictionarySP dict_sp(new StructuredData::Dictionary(result_obj_sp));
  if (dict_sp->GetType() == lldb::eStructuredDataTypeInvalid)
    return {};
  return dict_sp;
}

#include "lldb/Interpreter/CommandReturnObject.h"

bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallParsedCommandObject(
    PyObject *implementor, lldb::DebuggerSP debugger, lldb_private::StructuredDataImpl &args_impl,
    lldb_private::CommandReturnObject &cmd_retobj,
    lldb::ExecutionContextRefSP exe_ctx_ref_sp) {

  PyErr_Cleaner py_err_cleaner(true);

  PythonObject self(PyRefType::Borrowed, implementor);
  auto pfunc = self.ResolveName<PythonCallable>("__call__");

  if (!pfunc.IsAllocated()) {
    cmd_retobj.AppendError("Could not find '__call__' method in implementation class");
    return false;
  }

  pfunc(SWIGBridge::ToSWIGWrapper(std::move(debugger)), SWIGBridge::ToSWIGWrapper(args_impl),
        SWIGBridge::ToSWIGWrapper(exe_ctx_ref_sp), SWIGBridge::ToSWIGWrapper(cmd_retobj).obj());

  return true;
}

PythonObject lldb_private::python::SWIGBridge::LLDBSWIGPythonCreateOSPlugin(
    const char *python_class_name, const char *session_dictionary_name,
    const lldb::ProcessSP &process_sp) {
  if (python_class_name == NULL || python_class_name[0] == '\0' ||
      !session_dictionary_name)
    return PythonObject();

  PyErr_Cleaner py_err_cleaner(true);

  auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
      session_dictionary_name);
  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
      python_class_name, dict);

  if (!pfunc.IsAllocated())
    return PythonObject();

  return pfunc(SWIGBridge::ToSWIGWrapper(process_sp));
}

PythonObject lldb_private::python::SWIGBridge::LLDBSWIGPython_CreateFrameRecognizer(
    const char *python_class_name, const char *session_dictionary_name) {
  if (python_class_name == NULL || python_class_name[0] == '\0' ||
      !session_dictionary_name)
    return PythonObject();

  PyErr_Cleaner py_err_cleaner(true);

  auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
      session_dictionary_name);
  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
      python_class_name, dict);

  if (!pfunc.IsAllocated())
    return PythonObject();

  return pfunc();
}

PyObject *lldb_private::python::SWIGBridge::LLDBSwigPython_GetRecognizedArguments(
    PyObject *implementor, const lldb::StackFrameSP &frame_sp) {
  static char callee_name[] = "get_recognized_arguments";

  PythonObject arg = SWIGBridge::ToSWIGWrapper(frame_sp);

  PythonString str(callee_name);
  PyObject *result =
      PyObject_CallMethodObjArgs(implementor, str.get(), arg.get(), NULL);
  return result;
}

bool lldb_private::python::SWIGBridge::LLDBSwigPython_ShouldHide(
    PyObject *implementor, const lldb::StackFrameSP &frame_sp) {
  static char callee_name[] = "should_hide";

  PythonObject arg = SWIGBridge::ToSWIGWrapper(frame_sp);

  PythonString str(callee_name);

  PyObject *result =
      PyObject_CallMethodObjArgs(implementor, str.get(), arg.get(), NULL);
  bool ret_val = result ? PyObject_IsTrue(result) : false;
  Py_XDECREF(result);

  return ret_val;
}

void *lldb_private::python::SWIGBridge::LLDBSWIGPython_GetDynamicSetting(
    void *module, const char *setting, const lldb::TargetSP &target_sp) {
  if (!module || !setting)
    Py_RETURN_NONE;

  PyErr_Cleaner py_err_cleaner(true);
  PythonObject py_module(PyRefType::Borrowed, (PyObject *)module);
  auto pfunc = py_module.ResolveName<PythonCallable>("get_dynamic_setting");

  if (!pfunc.IsAllocated())
    Py_RETURN_NONE;

  auto result = pfunc(SWIGBridge::ToSWIGWrapper(target_sp), PythonString(setting));

  return result.release();
}

bool lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordProcess(
    const char *python_function_name, const char *session_dictionary_name,
    const lldb::ProcessSP &process, std::string &output) {

  if (python_function_name == NULL || python_function_name[0] == '\0' ||
      !session_dictionary_name)
    return false;

  PyErr_Cleaner py_err_cleaner(true);

  auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
      session_dictionary_name);
  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
      python_function_name, dict);

  if (!pfunc.IsAllocated())
    return false;

  auto result = pfunc(SWIGBridge::ToSWIGWrapper(process), dict);

  output = result.Str().GetString().str();

  return true;
}

std::optional<std::string> lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordThread(
    const char *python_function_name, const char *session_dictionary_name,
    lldb::ThreadSP thread) {
  if (python_function_name == NULL || python_function_name[0] == '\0' ||
      !session_dictionary_name)
    return std::nullopt;

  PyErr_Cleaner py_err_cleaner(true);

  auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
      session_dictionary_name);
  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
      python_function_name, dict);

  if (!pfunc.IsAllocated())
    return std::nullopt;

  auto result = pfunc(SWIGBridge::ToSWIGWrapper(std::move(thread)), dict);

  return result.Str().GetString().str();
}

bool lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordTarget(
    const char *python_function_name, const char *session_dictionary_name,
    const lldb::TargetSP &target, std::string &output) {

  if (python_function_name == NULL || python_function_name[0] == '\0' ||
      !session_dictionary_name)
    return false;

  PyErr_Cleaner py_err_cleaner(true);

  auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
      session_dictionary_name);
  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
      python_function_name, dict);

  if (!pfunc.IsAllocated())
    return false;

  auto result = pfunc(SWIGBridge::ToSWIGWrapper(target), dict);

  output = result.Str().GetString().str();

  return true;
}

std::optional<std::string> lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordFrame(
    const char *python_function_name, const char *session_dictionary_name,
    lldb::StackFrameSP frame) {
  if (python_function_name == NULL || python_function_name[0] == '\0' ||
      !session_dictionary_name)
    return std::nullopt;

  PyErr_Cleaner py_err_cleaner(true);

  auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
      session_dictionary_name);
  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
      python_function_name, dict);

  if (!pfunc.IsAllocated())
    return std::nullopt;

  auto result = pfunc(SWIGBridge::ToSWIGWrapper(std::move(frame)), dict);

  return result.Str().GetString().str();
}

bool lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordValue(
    const char *python_function_name, const char *session_dictionary_name,
    const lldb::ValueObjectSP &value, std::string &output) {

  if (python_function_name == NULL || python_function_name[0] == '\0' ||
      !session_dictionary_name)
    return false;

  PyErr_Cleaner py_err_cleaner(true);

  auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
      session_dictionary_name);
  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
      python_function_name, dict);

  if (!pfunc.IsAllocated())
    return false;

  auto result = pfunc(SWIGBridge::ToSWIGWrapper(value), dict);

  output = result.Str().GetString().str();

  return true;
}

bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallModuleNewTarget(
    const char *python_module_name, const char *session_dictionary_name,
    lldb::TargetSP target_sp) {
  std::string python_function_name_string = python_module_name;
  python_function_name_string += ".__lldb_module_added_to_target";
  const char *python_function_name = python_function_name_string.c_str();

  PyErr_Cleaner py_err_cleaner(true);

  auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
      session_dictionary_name);
  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
      python_function_name, dict);

  if (!pfunc.IsAllocated())
    return true;

  pfunc(SWIGBridge::ToSWIGWrapper(std::move(target_sp)), dict);

  return true;
}

bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallModuleInit(
    const char *python_module_name, const char *session_dictionary_name,
    lldb::DebuggerSP debugger) {
  std::string python_function_name_string = python_module_name;
  python_function_name_string += ".__lldb_init_module";
  const char *python_function_name = python_function_name_string.c_str();

  PyErr_Cleaner py_err_cleaner(true);

  auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
      session_dictionary_name);
  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
      python_function_name, dict);

  // This method is optional and need not exist.  So if we don't find it,
  // it's actually a success, not a failure.
  if (!pfunc.IsAllocated())
    return true;

  pfunc(SWIGBridge::ToSWIGWrapper(std::move(debugger)), dict);

  return true;
}

lldb::ValueObjectSP lldb_private::python::SWIGBridge::LLDBSWIGPython_GetValueObjectSPFromSBValue(
    void *data) {
  lldb::ValueObjectSP valobj_sp;
  if (data) {
    lldb::SBValue *sb_ptr = (lldb::SBValue *)data;
    valobj_sp = sb_ptr->GetSP();
  }
  return valobj_sp;
}

// For the LogOutputCallback functions
static void LLDBSwigPythonCallPythonLogOutputCallback(const char *str,
                                                      void *baton) {
  if (baton != Py_None) {
    SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    PyObject *result = PyObject_CallFunction(
        reinterpret_cast<PyObject *>(baton), const_cast<char *>("s"), str);
    Py_XDECREF(result);
    SWIG_PYTHON_THREAD_END_BLOCK;
  }
}

// For CommandPrintCallback functions
static CommandReturnObjectCallbackResult LLDBSwigPythonCallPythonCommandPrintCallback(SBCommandReturnObject& result, void *callback_baton) {
  SWIG_Python_Thread_Block swig_thread_block;

  PyErr_Cleaner py_err_cleaner(true);

  PythonObject result_arg = SWIGBridge::ToSWIGWrapper(
      std::make_unique<SBCommandReturnObject>(result));
  PythonCallable callable =
      Retain<PythonCallable>(reinterpret_cast<PyObject *>(callback_baton));

  if (!callable.IsValid())
    return eCommandReturnObjectPrintCallbackSkipped;

  PythonObject callback_result = callable(result_arg);

  long long ret_val = unwrapOrSetPythonException(As<long long>(callback_result));
  return (CommandReturnObjectCallbackResult)ret_val;
}

// For DebuggerTerminateCallback functions
static void LLDBSwigPythonCallPythonSBDebuggerTerminateCallback(lldb::user_id_t debugger_id,
                                                      void *baton) {
  if (baton != Py_None) {
    SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    PyObject *result = PyObject_CallFunction(
        reinterpret_cast<PyObject *>(baton), const_cast<char *>("l"), debugger_id);
    Py_XDECREF(result);
    SWIG_PYTHON_THREAD_END_BLOCK;
  }
}

static bool LLDBSwigPythonCallPythonSBCommandInterpreterSetCommandOverrideCallback(void *baton, const char **argv) {
  bool ret_val = false;
  if (baton != Py_None) {
    SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    // Create a PyList of items since we're going to pass it to the callback as a tuple
    // of arguments.
    PyObject *py_argv = PyList_New(0);
    for (const char **arg = argv; arg && *arg; arg++) {
      std::string arg_string = *arg;
      PyObject *py_string = PyUnicode_FromStringAndSize(arg_string.c_str(), arg_string.size());
      PyList_Append(py_argv, py_string);
    }

    PyObject *result = PyObject_CallObject(
        reinterpret_cast<PyObject *>(baton), PyList_AsTuple(py_argv));
    ret_val = result ? PyObject_IsTrue(result) : false;
    Py_XDECREF(result);
    SWIG_PYTHON_THREAD_END_BLOCK;
  }
  return ret_val;
}

static SBError LLDBSwigPythonCallLocateModuleCallback(
    void *callback_baton, const SBModuleSpec &module_spec_sb,
    SBFileSpec &module_file_spec_sb, SBFileSpec &symbol_file_spec_sb) {
  SWIG_Python_Thread_Block swig_thread_block;

  PyErr_Cleaner py_err_cleaner(true);
  PythonObject module_spec_arg = SWIGBridge::ToSWIGWrapper(
      std::make_unique<SBModuleSpec>(module_spec_sb));
  PythonObject module_file_spec_arg = SWIGBridge::ToSWIGWrapper(
      std::make_unique<SBFileSpec>(module_file_spec_sb));
  PythonObject symbol_file_spec_arg = SWIGBridge::ToSWIGWrapper(
      std::make_unique<SBFileSpec>(symbol_file_spec_sb));

  PythonCallable callable =
      Retain<PythonCallable>(reinterpret_cast<PyObject *>(callback_baton));
  if (!callable.IsValid()) {
    return SBError("The callback callable is not valid.");
  }

  PythonObject result = callable(module_spec_arg, module_file_spec_arg,
                                 symbol_file_spec_arg);

  if (!result.IsAllocated())
    return SBError("No result.");
  lldb::SBError *sb_error_ptr = nullptr;
  if (SWIG_ConvertPtr(result.get(), (void **)&sb_error_ptr,
                      SWIGTYPE_p_lldb__SBError, 0) == -1) {
    return SBError("Result is not SBError.");
  }

  if (sb_error_ptr->Success()) {
    lldb::SBFileSpec *sb_module_file_spec_ptr = nullptr;
    if (SWIG_ConvertPtr(module_file_spec_arg.get(),
                        (void **)&sb_module_file_spec_ptr,
                        SWIGTYPE_p_lldb__SBFileSpec, 0) == -1)
      return SBError("module_file_spec is not SBFileSpec.");

    lldb::SBFileSpec *sb_symbol_file_spec_ptr = nullptr;
    if (SWIG_ConvertPtr(symbol_file_spec_arg.get(),
                        (void **)&sb_symbol_file_spec_ptr,
                        SWIGTYPE_p_lldb__SBFileSpec, 0) == -1)
      return SBError("symbol_file_spec is not SBFileSpec.");

    module_file_spec_sb = *sb_module_file_spec_ptr;
    symbol_file_spec_sb = *sb_symbol_file_spec_ptr;
  }

  return *sb_error_ptr;
}

#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_new_SBAddress__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBAddress *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBAddress *)new lldb::SBAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBAddress__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBAddress *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAddress" "', argument " "1"" of type '" "lldb::SBAddress const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBAddress" "', argument " "1"" of type '" "lldb::SBAddress const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBAddress *)new lldb::SBAddress((lldb::SBAddress const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBAddress__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBSection arg1 ;
  lldb::addr_t arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  lldb::SBAddress *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBSection,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAddress" "', argument " "1"" of type '" "lldb::SBSection""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBAddress" "', argument " "1"" of type '" "lldb::SBSection""'");
    } else {
      lldb::SBSection * temp = reinterpret_cast< lldb::SBSection * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBAddress *)new lldb::SBAddress(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBAddress__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::addr_t arg1 ;
  lldb::SBTarget *arg2 = 0 ;
  unsigned long long val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  lldb::SBAddress *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBAddress" "', argument " "1"" of type '" "lldb::addr_t""'");
  } 
  arg1 = static_cast< lldb::addr_t >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBAddress" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBAddress" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBAddress *)new lldb::SBAddress(arg1,*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBAddress(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBAddress", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBAddress__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBAddress__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SBAddress__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SBAddress__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBAddress'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBAddress::SBAddress()\n"
    "    lldb::SBAddress::SBAddress(lldb::SBAddress const &)\n"
    "    lldb::SBAddress::SBAddress(lldb::SBSection,lldb::addr_t)\n"
    "    lldb::SBAddress::SBAddress(lldb::addr_t,lldb::SBTarget &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBAddress" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress___nonzero__" "', argument " "1"" of type '" "lldb::SBAddress const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBAddress const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  lldb::SBAddress *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAddress___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress___ne__" "', argument " "1"" of type '" "lldb::SBAddress const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAddress___ne__" "', argument " "2"" of type '" "lldb::SBAddress const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAddress___ne__" "', argument " "2"" of type '" "lldb::SBAddress const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAddress * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBAddress const *)arg1)->operator !=((lldb::SBAddress const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBAddress_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_IsValid" "', argument " "1"" of type '" "lldb::SBAddress const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBAddress const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_Clear" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress_GetFileAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetFileAddress" "', argument " "1"" of type '" "lldb::SBAddress const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)((lldb::SBAddress const *)arg1)->GetFileAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress_GetLoadAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  lldb::SBTarget *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::addr_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAddress_GetLoadAddress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetLoadAddress" "', argument " "1"" of type '" "lldb::SBAddress const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAddress_GetLoadAddress" "', argument " "2"" of type '" "lldb::SBTarget const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAddress_GetLoadAddress" "', argument " "2"" of type '" "lldb::SBTarget const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)((lldb::SBAddress const *)arg1)->GetLoadAddress((lldb::SBTarget const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress_SetAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  lldb::SBSection arg2 ;
  lldb::addr_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAddress_SetAddress", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_SetAddress" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBSection,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAddress_SetAddress" "', argument " "2"" of type '" "lldb::SBSection""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAddress_SetAddress" "', argument " "2"" of type '" "lldb::SBSection""'");
    } else {
      lldb::SBSection * temp = reinterpret_cast< lldb::SBSection * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBAddress_SetAddress" "', argument " "3"" of type '" "lldb::addr_t""'");
  } 
  arg3 = static_cast< lldb::addr_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAddress(SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress_SetLoadAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  lldb::addr_t arg2 ;
  lldb::SBTarget *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAddress_SetLoadAddress", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_SetLoadAddress" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAddress_SetLoadAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBTarget,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBAddress_SetLoadAddress" "', argument " "3"" of type '" "lldb::SBTarget &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAddress_SetLoadAddress" "', argument " "3"" of type '" "lldb::SBTarget &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBTarget * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetLoadAddress(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress_OffsetAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  lldb::addr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAddress_OffsetAddress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_OffsetAddress" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAddress_OffsetAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->OffsetAddress(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAddress_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetDescription" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAddress_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAddress_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress_GetSymbolContext(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBSymbolContext result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAddress_GetSymbolContext", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetSymbolContext" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAddress_GetSymbolContext" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSymbolContext(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContext(result)), SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress_GetSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBSection result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetSection" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSection();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSection(result)), SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress_GetOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetOffset" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->GetOffset();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress_GetModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBModule result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetModule" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetModule();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBModule(result)), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress_GetCompileUnit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBCompileUnit result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetCompileUnit" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetCompileUnit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBCompileUnit(result)), SWIGTYPE_p_lldb__SBCompileUnit, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress_GetFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFunction result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetFunction" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetFunction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFunction(result)), SWIGTYPE_p_lldb__SBFunction, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress_GetBlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBlock result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetBlock" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetBlock();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBlock(result)), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress_GetSymbol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBSymbol result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetSymbol" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSymbol();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbol(result)), SWIGTYPE_p_lldb__SBSymbol, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress_GetLineEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBLineEntry result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetLineEntry" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetLineEntry();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBLineEntry(result)), SWIGTYPE_p_lldb__SBLineEntry, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddress___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress___repr__" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBAddress___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBAddress_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBAddress, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBAddress_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBAddressRange__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBAddressRange *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBAddressRange *)new lldb::SBAddressRange();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddressRange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBAddressRange__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBAddressRange *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBAddressRange *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBAddressRange,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAddressRange" "', argument " "1"" of type '" "lldb::SBAddressRange const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBAddressRange" "', argument " "1"" of type '" "lldb::SBAddressRange const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRange * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBAddressRange *)new lldb::SBAddressRange((lldb::SBAddressRange const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddressRange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBAddressRange__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBAddress arg1 ;
  lldb::addr_t arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  lldb::SBAddressRange *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAddressRange" "', argument " "1"" of type '" "lldb::SBAddress""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBAddressRange" "', argument " "1"" of type '" "lldb::SBAddress""'");
    } else {
      lldb::SBAddress * temp = reinterpret_cast< lldb::SBAddress * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBAddressRange" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBAddressRange *)new lldb::SBAddressRange(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddressRange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBAddressRange(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBAddressRange", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBAddressRange__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBAddressRange, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBAddressRange__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SBAddressRange__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBAddressRange'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBAddressRange::SBAddressRange()\n"
    "    lldb::SBAddressRange::SBAddressRange(lldb::SBAddressRange const &)\n"
    "    lldb::SBAddressRange::SBAddressRange(lldb::SBAddress,lldb::addr_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBAddressRange(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddressRange *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddressRange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBAddressRange" "', argument " "1"" of type '" "lldb::SBAddressRange *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRange * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddressRange_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddressRange *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddressRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddressRange_Clear" "', argument " "1"" of type '" "lldb::SBAddressRange *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRange * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddressRange_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddressRange *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddressRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddressRange_IsValid" "', argument " "1"" of type '" "lldb::SBAddressRange const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRange * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBAddressRange const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddressRange_GetBaseAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddressRange *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddressRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddressRange_GetBaseAddress" "', argument " "1"" of type '" "lldb::SBAddressRange const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRange * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBAddressRange const *)arg1)->GetBaseAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddressRange_GetByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddressRange *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddressRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddressRange_GetByteSize" "', argument " "1"" of type '" "lldb::SBAddressRange const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRange * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)((lldb::SBAddressRange const *)arg1)->GetByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddressRange___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddressRange *arg1 = 0 ;
  lldb::SBAddressRange *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAddressRange___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddressRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddressRange___eq__" "', argument " "1"" of type '" "lldb::SBAddressRange *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRange * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddressRange,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAddressRange___eq__" "', argument " "2"" of type '" "lldb::SBAddressRange const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAddressRange___eq__" "', argument " "2"" of type '" "lldb::SBAddressRange const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAddressRange * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator ==((lldb::SBAddressRange const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBAddressRange___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddressRange *arg1 = 0 ;
  lldb::SBAddressRange *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAddressRange___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddressRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddressRange___ne__" "', argument " "1"" of type '" "lldb::SBAddressRange *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRange * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddressRange,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAddressRange___ne__" "', argument " "2"" of type '" "lldb::SBAddressRange const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAddressRange___ne__" "', argument " "2"" of type '" "lldb::SBAddressRange const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAddressRange * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator !=((lldb::SBAddressRange const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBAddressRange_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddressRange *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::SBTarget arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAddressRange_GetDescription", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddressRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddressRange_GetDescription" "', argument " "1"" of type '" "lldb::SBAddressRange *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRange * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAddressRange_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAddressRange_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBAddressRange_GetDescription" "', argument " "3"" of type '" "lldb::SBTarget const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAddressRange_GetDescription" "', argument " "3"" of type '" "lldb::SBTarget const""'");
    } else {
      lldb::SBTarget * temp = reinterpret_cast< lldb::SBTarget * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBAddressRange_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBAddressRange, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBAddressRange_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBAddressRangeList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBAddressRangeList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBAddressRangeList *)new lldb::SBAddressRangeList();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddressRangeList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBAddressRangeList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBAddressRangeList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBAddressRangeList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBAddressRangeList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAddressRangeList" "', argument " "1"" of type '" "lldb::SBAddressRangeList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBAddressRangeList" "', argument " "1"" of type '" "lldb::SBAddressRangeList const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRangeList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBAddressRangeList *)new lldb::SBAddressRangeList((lldb::SBAddressRangeList const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddressRangeList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBAddressRangeList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBAddressRangeList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBAddressRangeList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBAddressRangeList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBAddressRangeList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBAddressRangeList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBAddressRangeList::SBAddressRangeList()\n"
    "    lldb::SBAddressRangeList::SBAddressRangeList(lldb::SBAddressRangeList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBAddressRangeList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddressRangeList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddressRangeList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBAddressRangeList" "', argument " "1"" of type '" "lldb::SBAddressRangeList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRangeList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddressRangeList_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddressRangeList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddressRangeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddressRangeList_GetSize" "', argument " "1"" of type '" "lldb::SBAddressRangeList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRangeList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBAddressRangeList const *)arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddressRangeList_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddressRangeList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddressRangeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddressRangeList_Clear" "', argument " "1"" of type '" "lldb::SBAddressRangeList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRangeList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddressRangeList_GetAddressRangeAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddressRangeList *arg1 = 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBAddressRange result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAddressRangeList_GetAddressRangeAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddressRangeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddressRangeList_GetAddressRangeAtIndex" "', argument " "1"" of type '" "lldb::SBAddressRangeList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRangeList * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAddressRangeList_GetAddressRangeAtIndex" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetAddressRangeAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddressRange(result)), SWIGTYPE_p_lldb__SBAddressRange, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddressRangeList_Append__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBAddressRangeList *arg1 = 0 ;
  lldb::SBAddressRange *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddressRangeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddressRangeList_Append" "', argument " "1"" of type '" "lldb::SBAddressRangeList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRangeList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddressRange,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAddressRangeList_Append" "', argument " "2"" of type '" "lldb::SBAddressRange const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAddressRangeList_Append" "', argument " "2"" of type '" "lldb::SBAddressRange const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAddressRange * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Append((lldb::SBAddressRange const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddressRangeList_Append__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBAddressRangeList *arg1 = 0 ;
  lldb::SBAddressRangeList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddressRangeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddressRangeList_Append" "', argument " "1"" of type '" "lldb::SBAddressRangeList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRangeList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddressRangeList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAddressRangeList_Append" "', argument " "2"" of type '" "lldb::SBAddressRangeList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAddressRangeList_Append" "', argument " "2"" of type '" "lldb::SBAddressRangeList const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAddressRangeList * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Append((lldb::SBAddressRangeList const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAddressRangeList_Append(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBAddressRangeList_Append", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBAddressRangeList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBAddressRange, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBAddressRangeList_Append__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBAddressRangeList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBAddressRangeList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBAddressRangeList_Append__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBAddressRangeList_Append'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBAddressRangeList::Append(lldb::SBAddressRange const &)\n"
    "    lldb::SBAddressRangeList::Append(lldb::SBAddressRangeList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBAddressRangeList_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAddressRangeList *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::SBTarget *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAddressRangeList_GetDescription", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAddressRangeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddressRangeList_GetDescription" "', argument " "1"" of type '" "lldb::SBAddressRangeList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAddressRangeList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAddressRangeList_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAddressRangeList_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBAddressRangeList_GetDescription" "', argument " "3"" of type '" "lldb::SBTarget const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAddressRangeList_GetDescription" "', argument " "3"" of type '" "lldb::SBTarget const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBTarget * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,(lldb::SBTarget const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBAddressRangeList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBAddressRangeList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBAddressRangeList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::pid_t arg1 ;
  unsigned long long val1 ;
  int ecode1 = 0 ;
  lldb::SBAttachInfo *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBAttachInfo" "', argument " "1"" of type '" "lldb::pid_t""'");
  } 
  arg1 = static_cast< lldb::pid_t >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  bool arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  lldb::SBAttachInfo *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAttachInfo" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBAttachInfo" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo((char const *)arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  lldb::SBAttachInfo *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAttachInfo" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBAttachInfo" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SBAttachInfo" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo((char const *)arg1,arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBAttachInfo *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBAttachInfo,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAttachInfo" "', argument " "1"" of type '" "lldb::SBAttachInfo const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBAttachInfo" "', argument " "1"" of type '" "lldb::SBAttachInfo const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo((lldb::SBAttachInfo const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBAttachInfo(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBAttachInfo", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBAttachInfo__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBAttachInfo__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SBAttachInfo__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SBAttachInfo__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SBAttachInfo__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBAttachInfo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBAttachInfo::SBAttachInfo()\n"
    "    lldb::SBAttachInfo::SBAttachInfo(lldb::pid_t)\n"
    "    lldb::SBAttachInfo::SBAttachInfo(char const *,bool)\n"
    "    lldb::SBAttachInfo::SBAttachInfo(char const *,bool,bool)\n"
    "    lldb::SBAttachInfo::SBAttachInfo(lldb::SBAttachInfo const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBAttachInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBAttachInfo" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_GetProcessID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::pid_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetProcessID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::pid_t)(arg1)->GetProcessID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetProcessID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  lldb::pid_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAttachInfo_SetProcessID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetProcessID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetProcessID" "', argument " "2"" of type '" "lldb::pid_t""'");
  } 
  arg2 = static_cast< lldb::pid_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetProcessID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetExecutable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetExecutable" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAttachInfo_SetExecutable" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetExecutable((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetExecutable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  lldb::SBFileSpec arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetExecutable" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAttachInfo_SetExecutable" "', argument " "2"" of type '" "lldb::SBFileSpec""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAttachInfo_SetExecutable" "', argument " "2"" of type '" "lldb::SBFileSpec""'");
    } else {
      lldb::SBFileSpec * temp = reinterpret_cast< lldb::SBFileSpec * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetExecutable(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetExecutable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBAttachInfo_SetExecutable", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBAttachInfo, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBAttachInfo_SetExecutable__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBAttachInfo, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBAttachInfo_SetExecutable__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBAttachInfo_SetExecutable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBAttachInfo::SetExecutable(char const *)\n"
    "    lldb::SBAttachInfo::SetExecutable(lldb::SBFileSpec)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_GetWaitForLaunch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetWaitForLaunch" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetWaitForLaunch();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetWaitForLaunch__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetWaitForLaunch" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetWaitForLaunch" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetWaitForLaunch(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetWaitForLaunch__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetWaitForLaunch" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetWaitForLaunch" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBAttachInfo_SetWaitForLaunch" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetWaitForLaunch(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetWaitForLaunch(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBAttachInfo_SetWaitForLaunch", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBAttachInfo, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBAttachInfo_SetWaitForLaunch__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBAttachInfo, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBAttachInfo_SetWaitForLaunch__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBAttachInfo_SetWaitForLaunch'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBAttachInfo::SetWaitForLaunch(bool)\n"
    "    lldb::SBAttachInfo::SetWaitForLaunch(bool,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_GetIgnoreExisting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetIgnoreExisting" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetIgnoreExisting();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetIgnoreExisting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAttachInfo_SetIgnoreExisting", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetIgnoreExisting" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetIgnoreExisting" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetIgnoreExisting(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_GetResumeCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetResumeCount" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetResumeCount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetResumeCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAttachInfo_SetResumeCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetResumeCount" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetResumeCount" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetResumeCount(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_GetProcessPluginName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetProcessPluginName" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetProcessPluginName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetProcessPluginName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAttachInfo_SetProcessPluginName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetProcessPluginName" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAttachInfo_SetProcessPluginName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetProcessPluginName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_GetUserID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetUserID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetUserID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_GetGroupID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetGroupID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetGroupID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_UserIDIsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_UserIDIsValid" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->UserIDIsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_GroupIDIsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GroupIDIsValid" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GroupIDIsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetUserID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAttachInfo_SetUserID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetUserID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetUserID" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetUserID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetGroupID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAttachInfo_SetGroupID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetGroupID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetGroupID" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetGroupID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_GetEffectiveUserID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetEffectiveUserID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetEffectiveUserID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_GetEffectiveGroupID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetEffectiveGroupID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetEffectiveGroupID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_EffectiveUserIDIsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_EffectiveUserIDIsValid" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->EffectiveUserIDIsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_EffectiveGroupIDIsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_EffectiveGroupIDIsValid" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->EffectiveGroupIDIsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetEffectiveUserID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAttachInfo_SetEffectiveUserID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetEffectiveUserID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetEffectiveUserID" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetEffectiveUserID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetEffectiveGroupID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAttachInfo_SetEffectiveGroupID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetEffectiveGroupID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetEffectiveGroupID" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetEffectiveGroupID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_GetParentProcessID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::pid_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetParentProcessID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::pid_t)(arg1)->GetParentProcessID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetParentProcessID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  lldb::pid_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAttachInfo_SetParentProcessID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetParentProcessID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetParentProcessID" "', argument " "2"" of type '" "lldb::pid_t""'");
  } 
  arg2 = static_cast< lldb::pid_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetParentProcessID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_ParentProcessIDIsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_ParentProcessIDIsValid" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->ParentProcessIDIsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_GetListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBListener result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetListener" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetListener();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBListener(result)), SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  lldb::SBListener *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAttachInfo_SetListener", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetListener" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBListener,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAttachInfo_SetListener" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAttachInfo_SetListener" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBListener * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetListener(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_GetShadowListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBListener result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetShadowListener" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetShadowListener();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBListener(result)), SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetShadowListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  lldb::SBListener *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAttachInfo_SetShadowListener", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetShadowListener" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBListener,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAttachInfo_SetShadowListener" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAttachInfo_SetShadowListener" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBListener * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetShadowListener(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_GetScriptedProcessClassName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetScriptedProcessClassName" "', argument " "1"" of type '" "lldb::SBAttachInfo const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBAttachInfo const *)arg1)->GetScriptedProcessClassName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetScriptedProcessClassName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAttachInfo_SetScriptedProcessClassName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetScriptedProcessClassName" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAttachInfo_SetScriptedProcessClassName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetScriptedProcessClassName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_GetScriptedProcessDictionary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetScriptedProcessDictionary" "', argument " "1"" of type '" "lldb::SBAttachInfo const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBAttachInfo const *)arg1)->GetScriptedProcessDictionary();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBAttachInfo_SetScriptedProcessDictionary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBAttachInfo *arg1 = 0 ;
  lldb::SBStructuredData arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBAttachInfo_SetScriptedProcessDictionary", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetScriptedProcessDictionary" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStructuredData,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAttachInfo_SetScriptedProcessDictionary" "', argument " "2"" of type '" "lldb::SBStructuredData""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBAttachInfo_SetScriptedProcessDictionary" "', argument " "2"" of type '" "lldb::SBStructuredData""'");
    } else {
      lldb::SBStructuredData * temp = reinterpret_cast< lldb::SBStructuredData * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetScriptedProcessDictionary(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBAttachInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBAttachInfo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBAttachInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBBlock__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBBlock *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBBlock *)new lldb::SBBlock();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBBlock__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBBlock *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBBlock,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBlock" "', argument " "1"" of type '" "lldb::SBBlock const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBBlock" "', argument " "1"" of type '" "lldb::SBBlock const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBBlock *)new lldb::SBBlock((lldb::SBBlock const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBBlock(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBBlock", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBBlock__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBBlock__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBBlock'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBBlock::SBBlock()\n"
    "    lldb::SBBlock::SBBlock(lldb::SBBlock const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBBlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBBlock" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_IsInlined(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_IsInlined" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBlock const *)arg1)->IsInlined();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock___nonzero__" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBlock const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_IsValid" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBlock const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetInlinedName" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBBlock const *)arg1)->GetInlinedName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedCallSiteFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetInlinedCallSiteFile" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBBlock const *)arg1)->GetInlinedCallSiteFile();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedCallSiteLine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetInlinedCallSiteLine" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBBlock const *)arg1)->GetInlinedCallSiteLine();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedCallSiteColumn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetInlinedCallSiteColumn" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBBlock const *)arg1)->GetInlinedCallSiteColumn();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetParent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBlock result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetParent" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetParent();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBlock(result)), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetSibling(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBlock result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetSibling" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSibling();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBlock(result)), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetFirstChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBlock result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetFirstChild" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetFirstChild();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBlock(result)), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetNumRanges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetNumRanges" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumRanges();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetRangeStartAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBlock_GetRangeStartAddress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetRangeStartAddress" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBlock_GetRangeStartAddress" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetRangeStartAddress(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetRangeEndAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBlock_GetRangeEndAddress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetRangeEndAddress" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBlock_GetRangeEndAddress" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetRangeEndAddress(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetRanges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBAddressRangeList result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetRanges" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetRanges();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddressRangeList(result)), SWIGTYPE_p_lldb__SBAddressRangeList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetRangeIndexForBlockAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  lldb::SBAddress arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBlock_GetRangeIndexForBlockAddress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetRangeIndexForBlockAddress" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBlock_GetRangeIndexForBlockAddress" "', argument " "2"" of type '" "lldb::SBAddress""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBlock_GetRangeIndexForBlockAddress" "', argument " "2"" of type '" "lldb::SBAddress""'");
    } else {
      lldb::SBAddress * temp = reinterpret_cast< lldb::SBAddress * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetRangeIndexForBlockAddress(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetVariables__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  lldb::SBFrame *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  lldb::DynamicValueType arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  lldb::SBValueList result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetVariables" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFrame,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBlock_GetVariables" "', argument " "2"" of type '" "lldb::SBFrame &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBlock_GetVariables" "', argument " "2"" of type '" "lldb::SBFrame &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFrame * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBBlock_GetVariables" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBBlock_GetVariables" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBBlock_GetVariables" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBBlock_GetVariables" "', argument " "6"" of type '" "lldb::DynamicValueType""'");
  } 
  arg6 = static_cast< lldb::DynamicValueType >(val6);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetVariables(*arg2,arg3,arg4,arg5,arg6);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValueList(result)), SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetVariables__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  lldb::SBTarget *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  lldb::SBValueList result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetVariables" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBlock_GetVariables" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBlock_GetVariables" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBBlock_GetVariables" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBBlock_GetVariables" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBBlock_GetVariables" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetVariables(*arg2,arg3,arg4,arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValueList(result)), SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetVariables(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBBlock_GetVariables", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBlock, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SBBlock_GetVariables__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBlock, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SBBlock_GetVariables__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBBlock_GetVariables'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBBlock::GetVariables(lldb::SBFrame &,bool,bool,bool,lldb::DynamicValueType)\n"
    "    lldb::SBBlock::GetVariables(lldb::SBTarget &,bool,bool,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetContainingInlinedBlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBlock result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetContainingInlinedBlock" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetContainingInlinedBlock();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBlock(result)), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBlock_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetDescription" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBlock_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBlock_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBlock___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock___repr__" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBBlock___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBBlock_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBBlock, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBBlock_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBBreakpoint__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBBreakpoint *)new lldb::SBBreakpoint();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBBreakpoint__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBBreakpoint *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBBreakpoint,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBreakpoint" "', argument " "1"" of type '" "lldb::SBBreakpoint const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBBreakpoint" "', argument " "1"" of type '" "lldb::SBBreakpoint const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBBreakpoint *)new lldb::SBBreakpoint((lldb::SBBreakpoint const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBBreakpoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBBreakpoint", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBBreakpoint__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBBreakpoint__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBBreakpoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBBreakpoint::SBBreakpoint()\n"
    "    lldb::SBBreakpoint::SBBreakpoint(lldb::SBBreakpoint const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBBreakpoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBBreakpoint" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  lldb::SBBreakpoint *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint___eq__" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBreakpoint,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint___eq__" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpoint___eq__" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBBreakpoint * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator ==((lldb::SBBreakpoint const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  lldb::SBBreakpoint *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint___ne__" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBreakpoint,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint___ne__" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpoint___ne__" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBBreakpoint * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator !=((lldb::SBBreakpoint const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::break_id_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetID" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::break_id_t)((lldb::SBBreakpoint const *)arg1)->GetID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint___nonzero__" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBreakpoint const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_IsValid" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBreakpoint const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_ClearAllBreakpointSites(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_ClearAllBreakpointSites" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->ClearAllBreakpointSites();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTarget result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetTarget" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBBreakpoint const *)arg1)->GetTarget();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_FindLocationByAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  lldb::addr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBBreakpointLocation result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_FindLocationByAddress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_FindLocationByAddress" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_FindLocationByAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindLocationByAddress(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpointLocation(result)), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_FindLocationIDByAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  lldb::addr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::break_id_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_FindLocationIDByAddress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_FindLocationIDByAddress" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_FindLocationIDByAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::break_id_t)(arg1)->FindLocationIDByAddress(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_FindLocationByID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  lldb::break_id_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBBreakpointLocation result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_FindLocationByID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_FindLocationByID" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_FindLocationByID" "', argument " "2"" of type '" "lldb::break_id_t""'");
  } 
  arg2 = static_cast< lldb::break_id_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindLocationByID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpointLocation(result)), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetLocationAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBBreakpointLocation result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_GetLocationAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetLocationAtIndex" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_GetLocationAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetLocationAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpointLocation(result)), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_SetEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_SetEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetEnabled" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_SetEnabled" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetEnabled(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_IsEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_IsEnabled" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsEnabled();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_SetOneShot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_SetOneShot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetOneShot" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_SetOneShot" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetOneShot(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_IsOneShot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_IsOneShot" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBreakpoint const *)arg1)->IsOneShot();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_IsInternal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_IsInternal" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsInternal();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetHitCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetHitCount" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBBreakpoint const *)arg1)->GetHitCount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_SetIgnoreCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_SetIgnoreCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetIgnoreCount" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_SetIgnoreCount" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetIgnoreCount(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetIgnoreCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetIgnoreCount" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBBreakpoint const *)arg1)->GetIgnoreCount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_SetCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_SetCondition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetCondition" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetCondition" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetCondition((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetCondition" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetCondition();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_SetAutoContinue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_SetAutoContinue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetAutoContinue" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_SetAutoContinue" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAutoContinue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetAutoContinue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetAutoContinue" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetAutoContinue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_SetThreadID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  lldb::tid_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_SetThreadID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetThreadID" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    PythonObject obj = Retain<PythonObject>(swig_obj[1]);
    lldb::tid_t value = unwrapOrSetPythonException(As<unsigned long long>(obj));
    if (PyErr_Occurred())
    SWIG_fail;
    arg2 = value;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetThreadID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetThreadID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::tid_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetThreadID" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::tid_t)(arg1)->GetThreadID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_SetThreadIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_SetThreadIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetThreadIndex" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_SetThreadIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetThreadIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetThreadIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetThreadIndex" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBBreakpoint const *)arg1)->GetThreadIndex();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_SetThreadName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_SetThreadName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetThreadName" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetThreadName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetThreadName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetThreadName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetThreadName" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBBreakpoint const *)arg1)->GetThreadName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_SetQueueName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_SetQueueName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetQueueName" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetQueueName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetQueueName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetQueueName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetQueueName" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBBreakpoint const *)arg1)->GetQueueName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_SetScriptCallbackFunction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetScriptCallbackFunction" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetScriptCallbackFunction" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetScriptCallbackFunction((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_SetScriptCallbackFunction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBStructuredData *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetScriptCallbackFunction" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetScriptCallbackFunction" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStructuredData,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBBreakpoint_SetScriptCallbackFunction" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpoint_SetScriptCallbackFunction" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBStructuredData * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetScriptCallbackFunction((char const *)arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_SetScriptCallbackFunction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBBreakpoint_SetScriptCallbackFunction", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBreakpoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBBreakpoint_SetScriptCallbackFunction__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBreakpoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBBreakpoint_SetScriptCallbackFunction__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBBreakpoint_SetScriptCallbackFunction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBBreakpoint::SetScriptCallbackFunction(char const *)\n"
    "    lldb::SBBreakpoint::SetScriptCallbackFunction(char const *,lldb::SBStructuredData &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_SetCommandLineCommands(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  lldb::SBStringList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_SetCommandLineCommands", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetCommandLineCommands" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpoint_SetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetCommandLineCommands(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetCommandLineCommands(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  lldb::SBStringList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_GetCommandLineCommands", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetCommandLineCommands" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_GetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpoint_GetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetCommandLineCommands(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_SetScriptCallbackBody(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_SetScriptCallbackBody", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetScriptCallbackBody" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetScriptCallbackBody" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetScriptCallbackBody((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_AddName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_AddName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_AddName" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_AddName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->AddName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_AddNameWithErrorHandling(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_AddNameWithErrorHandling", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_AddNameWithErrorHandling" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_AddNameWithErrorHandling" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->AddNameWithErrorHandling((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_RemoveName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_RemoveName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_RemoveName" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_RemoveName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->RemoveName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_MatchesName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_MatchesName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_MatchesName" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_MatchesName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->MatchesName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNames(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  lldb::SBStringList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_GetNames", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetNames" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_GetNames" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpoint_GetNames" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->GetNames(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNumResolvedLocations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetNumResolvedLocations" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBBreakpoint const *)arg1)->GetNumResolvedLocations();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNumLocations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetNumLocations" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBBreakpoint const *)arg1)->GetNumLocations();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetDescription__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetDescription" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpoint_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetDescription__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetDescription" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpoint_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBBreakpoint_GetDescription" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBBreakpoint_GetDescription", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBreakpoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBBreakpoint_GetDescription__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBreakpoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBBreakpoint_GetDescription__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBBreakpoint_GetDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBBreakpoint::GetDescription(lldb::SBStream &)\n"
    "    lldb::SBBreakpoint::GetDescription(lldb::SBStream &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_EventIsBreakpointEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_EventIsBreakpointEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpoint_EventIsBreakpointEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBBreakpoint::EventIsBreakpointEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetBreakpointEventTypeFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::BreakpointEventType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetBreakpointEventTypeFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpoint_GetBreakpointEventTypeFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::BreakpointEventType)lldb::SBBreakpoint::GetBreakpointEventTypeFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetBreakpointFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetBreakpointFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpoint_GetBreakpointFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBBreakpoint::GetBreakpointFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetBreakpointLocationAtIndexFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBBreakpointLocation result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_GetBreakpointLocationAtIndexFromEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetBreakpointLocationAtIndexFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpoint_GetBreakpointLocationAtIndexFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_GetBreakpointLocationAtIndexFromEvent" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBBreakpoint::GetBreakpointLocationAtIndexFromEvent((lldb::SBEvent const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpointLocation(result)), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNumBreakpointLocationsFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetNumBreakpointLocationsFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpoint_GetNumBreakpointLocationsFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)lldb::SBBreakpoint::GetNumBreakpointLocationsFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_IsHardware(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_IsHardware" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBreakpoint const *)arg1)->IsHardware();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_SetIsHardware(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_SetIsHardware", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetIsHardware" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_SetIsHardware" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetIsHardware(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_AddLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  lldb::SBAddress *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpoint_AddLocation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_AddLocation" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_AddLocation" "', argument " "2"" of type '" "lldb::SBAddress &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpoint_AddLocation" "', argument " "2"" of type '" "lldb::SBAddress &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAddress * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->AddLocation(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_AddFacadeLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBreakpointLocation result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_AddFacadeLocation" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->AddFacadeLocation();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpointLocation(result)), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint_SerializeToStructuredData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SerializeToStructuredData" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SerializeToStructuredData();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpoint___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint___repr__" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBBreakpoint___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBBreakpoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBBreakpoint, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBBreakpoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBBreakpointList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBreakpointList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTarget,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBreakpointList" "', argument " "1"" of type '" "lldb::SBTarget &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBBreakpointList" "', argument " "1"" of type '" "lldb::SBTarget &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBBreakpointList *)new lldb::SBBreakpointList(*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBBreakpointList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBBreakpointList" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointList_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_GetSize" "', argument " "1"" of type '" "lldb::SBBreakpointList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBBreakpointList const *)arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointList_GetBreakpointAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointList *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointList_GetBreakpointAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_GetBreakpointAtIndex" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointList_GetBreakpointAtIndex" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetBreakpointAtIndex(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointList_FindBreakpointByID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointList *arg1 = 0 ;
  lldb::break_id_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointList_FindBreakpointByID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_FindBreakpointByID" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointList_FindBreakpointByID" "', argument " "2"" of type '" "lldb::break_id_t""'");
  } 
  arg2 = static_cast< lldb::break_id_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindBreakpointByID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointList_Append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointList *arg1 = 0 ;
  lldb::SBBreakpoint *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointList_Append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_Append" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBreakpoint,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointList_Append" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpointList_Append" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBBreakpoint * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Append((lldb::SBBreakpoint const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointList_AppendIfUnique(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointList *arg1 = 0 ;
  lldb::SBBreakpoint *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointList_AppendIfUnique", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_AppendIfUnique" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBreakpoint,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointList_AppendIfUnique" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpointList_AppendIfUnique" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBBreakpoint * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->AppendIfUnique((lldb::SBBreakpoint const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointList_AppendByID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointList *arg1 = 0 ;
  lldb::break_id_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointList_AppendByID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_AppendByID" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointList_AppendByID" "', argument " "2"" of type '" "lldb::break_id_t""'");
  } 
  arg2 = static_cast< lldb::break_id_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->AppendByID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointList_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_Clear" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBBreakpointList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBBreakpointList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBBreakpointList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBBreakpointLocation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBBreakpointLocation *)new lldb::SBBreakpointLocation();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBBreakpointLocation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBBreakpointLocation *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBBreakpointLocation,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBreakpointLocation" "', argument " "1"" of type '" "lldb::SBBreakpointLocation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBBreakpointLocation" "', argument " "1"" of type '" "lldb::SBBreakpointLocation const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBBreakpointLocation *)new lldb::SBBreakpointLocation((lldb::SBBreakpointLocation const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBBreakpointLocation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBBreakpointLocation", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBBreakpointLocation__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBBreakpointLocation__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBBreakpointLocation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBBreakpointLocation::SBBreakpointLocation()\n"
    "    lldb::SBBreakpointLocation::SBBreakpointLocation(lldb::SBBreakpointLocation const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBBreakpointLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBBreakpointLocation" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::break_id_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetID" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::break_id_t)(arg1)->GetID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation___nonzero__" "', argument " "1"" of type '" "lldb::SBBreakpointLocation const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBreakpointLocation const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_IsValid" "', argument " "1"" of type '" "lldb::SBBreakpointLocation const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBreakpointLocation const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetAddress" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetLoadAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetLoadAddress" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->GetLoadAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointLocation_SetEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetEnabled" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointLocation_SetEnabled" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetEnabled(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_IsEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_IsEnabled" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsEnabled();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetHitCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetHitCount" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetHitCount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetIgnoreCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetIgnoreCount" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetIgnoreCount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetIgnoreCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointLocation_SetIgnoreCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetIgnoreCount" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointLocation_SetIgnoreCount" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetIgnoreCount(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointLocation_SetCondition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetCondition" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointLocation_SetCondition" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetCondition((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetCondition" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetCondition();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetAutoContinue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointLocation_SetAutoContinue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetAutoContinue" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointLocation_SetAutoContinue" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAutoContinue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetAutoContinue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetAutoContinue" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetAutoContinue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetScriptCallbackFunction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetScriptCallbackFunction" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointLocation_SetScriptCallbackFunction" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetScriptCallbackFunction((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetScriptCallbackFunction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBStructuredData *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetScriptCallbackFunction" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointLocation_SetScriptCallbackFunction" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStructuredData,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBBreakpointLocation_SetScriptCallbackFunction" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpointLocation_SetScriptCallbackFunction" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBStructuredData * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetScriptCallbackFunction((char const *)arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetScriptCallbackFunction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBBreakpointLocation_SetScriptCallbackFunction", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBreakpointLocation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBBreakpointLocation_SetScriptCallbackFunction__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBreakpointLocation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBBreakpointLocation_SetScriptCallbackFunction__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBBreakpointLocation_SetScriptCallbackFunction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBBreakpointLocation::SetScriptCallbackFunction(char const *)\n"
    "    lldb::SBBreakpointLocation::SetScriptCallbackFunction(char const *,lldb::SBStructuredData &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetScriptCallbackBody(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointLocation_SetScriptCallbackBody", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetScriptCallbackBody" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointLocation_SetScriptCallbackBody" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetScriptCallbackBody((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetCommandLineCommands(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  lldb::SBStringList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointLocation_SetCommandLineCommands", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetCommandLineCommands" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointLocation_SetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpointLocation_SetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetCommandLineCommands(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetCommandLineCommands(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  lldb::SBStringList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointLocation_GetCommandLineCommands", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetCommandLineCommands" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointLocation_GetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpointLocation_GetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetCommandLineCommands(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetThreadID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  lldb::tid_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointLocation_SetThreadID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetThreadID" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    PythonObject obj = Retain<PythonObject>(swig_obj[1]);
    lldb::tid_t value = unwrapOrSetPythonException(As<unsigned long long>(obj));
    if (PyErr_Occurred())
    SWIG_fail;
    arg2 = value;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetThreadID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetThreadID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::tid_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetThreadID" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::tid_t)(arg1)->GetThreadID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetThreadIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointLocation_SetThreadIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetThreadIndex" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointLocation_SetThreadIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetThreadIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetThreadIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetThreadIndex" "', argument " "1"" of type '" "lldb::SBBreakpointLocation const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBBreakpointLocation const *)arg1)->GetThreadIndex();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetThreadName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointLocation_SetThreadName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetThreadName" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointLocation_SetThreadName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetThreadName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetThreadName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetThreadName" "', argument " "1"" of type '" "lldb::SBBreakpointLocation const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBBreakpointLocation const *)arg1)->GetThreadName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetQueueName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointLocation_SetQueueName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetQueueName" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointLocation_SetQueueName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetQueueName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetQueueName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetQueueName" "', argument " "1"" of type '" "lldb::SBBreakpointLocation const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBBreakpointLocation const *)arg1)->GetQueueName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_IsResolved(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_IsResolved" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsResolved();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::DescriptionLevel arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointLocation_GetDescription", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetDescription" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointLocation_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpointLocation_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBBreakpointLocation_GetDescription" "', argument " "3"" of type '" "lldb::DescriptionLevel""'");
  } 
  arg3 = static_cast< lldb::DescriptionLevel >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetBreakpoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetBreakpoint" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetBreakpoint();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointLocation___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation___repr__" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBBreakpointLocation___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBBreakpointLocation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBBreakpointLocation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBBreakpointName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBBreakpointName *)new lldb::SBBreakpointName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpointName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBBreakpointName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBBreakpointName *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTarget,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBreakpointName" "', argument " "1"" of type '" "lldb::SBTarget &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBBreakpointName" "', argument " "1"" of type '" "lldb::SBTarget &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBBreakpointName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBBreakpointName *)new lldb::SBBreakpointName(*arg1,(char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpointName, SWIG_POINTER_NEW |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBBreakpointName__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBreakpoint *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBBreakpointName *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBBreakpoint,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBreakpointName" "', argument " "1"" of type '" "lldb::SBBreakpoint &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBBreakpointName" "', argument " "1"" of type '" "lldb::SBBreakpoint &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBBreakpointName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBBreakpointName *)new lldb::SBBreakpointName(*arg1,(char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpointName, SWIG_POINTER_NEW |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBBreakpointName__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBBreakpointName *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBBreakpointName,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBreakpointName" "', argument " "1"" of type '" "lldb::SBBreakpointName const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBBreakpointName" "', argument " "1"" of type '" "lldb::SBBreakpointName const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBBreakpointName *)new lldb::SBBreakpointName((lldb::SBBreakpointName const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpointName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBBreakpointName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBBreakpointName", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBBreakpointName__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBBreakpointName, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBBreakpointName__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SBBreakpointName__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SBBreakpointName__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBBreakpointName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBBreakpointName::SBBreakpointName()\n"
    "    lldb::SBBreakpointName::SBBreakpointName(lldb::SBTarget &,char const *)\n"
    "    lldb::SBBreakpointName::SBBreakpointName(lldb::SBBreakpoint &,char const *)\n"
    "    lldb::SBBreakpointName::SBBreakpointName(lldb::SBBreakpointName const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBBreakpointName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBBreakpointName" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  lldb::SBBreakpointName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName___eq__" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBreakpointName,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointName___eq__" "', argument " "2"" of type '" "lldb::SBBreakpointName const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpointName___eq__" "', argument " "2"" of type '" "lldb::SBBreakpointName const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBBreakpointName * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator ==((lldb::SBBreakpointName const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  lldb::SBBreakpointName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName___ne__" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBreakpointName,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointName___ne__" "', argument " "2"" of type '" "lldb::SBBreakpointName const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpointName___ne__" "', argument " "2"" of type '" "lldb::SBBreakpointName const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBBreakpointName * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator !=((lldb::SBBreakpointName const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName___nonzero__" "', argument " "1"" of type '" "lldb::SBBreakpointName const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBreakpointName const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_IsValid" "', argument " "1"" of type '" "lldb::SBBreakpointName const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBreakpointName const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_GetName" "', argument " "1"" of type '" "lldb::SBBreakpointName const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBBreakpointName const *)arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_SetEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetEnabled" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointName_SetEnabled" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetEnabled(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_IsEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_IsEnabled" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsEnabled();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetOneShot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_SetOneShot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetOneShot" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointName_SetOneShot" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetOneShot(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_IsOneShot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_IsOneShot" "', argument " "1"" of type '" "lldb::SBBreakpointName const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBreakpointName const *)arg1)->IsOneShot();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetIgnoreCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_SetIgnoreCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetIgnoreCount" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointName_SetIgnoreCount" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetIgnoreCount(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_GetIgnoreCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_GetIgnoreCount" "', argument " "1"" of type '" "lldb::SBBreakpointName const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBBreakpointName const *)arg1)->GetIgnoreCount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_SetCondition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetCondition" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointName_SetCondition" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetCondition((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_GetCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_GetCondition" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetCondition();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetAutoContinue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_SetAutoContinue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetAutoContinue" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointName_SetAutoContinue" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAutoContinue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_GetAutoContinue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_GetAutoContinue" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetAutoContinue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetThreadID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  lldb::tid_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_SetThreadID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetThreadID" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    PythonObject obj = Retain<PythonObject>(swig_obj[1]);
    lldb::tid_t value = unwrapOrSetPythonException(As<unsigned long long>(obj));
    if (PyErr_Occurred())
    SWIG_fail;
    arg2 = value;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetThreadID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_GetThreadID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::tid_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_GetThreadID" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::tid_t)(arg1)->GetThreadID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetThreadIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_SetThreadIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetThreadIndex" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointName_SetThreadIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetThreadIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_GetThreadIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_GetThreadIndex" "', argument " "1"" of type '" "lldb::SBBreakpointName const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBBreakpointName const *)arg1)->GetThreadIndex();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetThreadName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_SetThreadName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetThreadName" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointName_SetThreadName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetThreadName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_GetThreadName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_GetThreadName" "', argument " "1"" of type '" "lldb::SBBreakpointName const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBBreakpointName const *)arg1)->GetThreadName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetQueueName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_SetQueueName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetQueueName" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointName_SetQueueName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetQueueName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_GetQueueName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_GetQueueName" "', argument " "1"" of type '" "lldb::SBBreakpointName const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBBreakpointName const *)arg1)->GetQueueName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetScriptCallbackFunction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetScriptCallbackFunction" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointName_SetScriptCallbackFunction" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetScriptCallbackFunction((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetScriptCallbackFunction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBStructuredData *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetScriptCallbackFunction" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointName_SetScriptCallbackFunction" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStructuredData,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBBreakpointName_SetScriptCallbackFunction" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpointName_SetScriptCallbackFunction" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBStructuredData * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetScriptCallbackFunction((char const *)arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetScriptCallbackFunction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBBreakpointName_SetScriptCallbackFunction", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBreakpointName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBBreakpointName_SetScriptCallbackFunction__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBreakpointName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBBreakpointName_SetScriptCallbackFunction__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBBreakpointName_SetScriptCallbackFunction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBBreakpointName::SetScriptCallbackFunction(char const *)\n"
    "    lldb::SBBreakpointName::SetScriptCallbackFunction(char const *,lldb::SBStructuredData &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetCommandLineCommands(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  lldb::SBStringList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_SetCommandLineCommands", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetCommandLineCommands" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointName_SetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpointName_SetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetCommandLineCommands(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_GetCommandLineCommands(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  lldb::SBStringList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_GetCommandLineCommands", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_GetCommandLineCommands" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointName_GetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpointName_GetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetCommandLineCommands(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetScriptCallbackBody(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_SetScriptCallbackBody", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetScriptCallbackBody" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointName_SetScriptCallbackBody" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetScriptCallbackBody((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_GetHelpString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_GetHelpString" "', argument " "1"" of type '" "lldb::SBBreakpointName const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBBreakpointName const *)arg1)->GetHelpString();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetHelpString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_SetHelpString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetHelpString" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointName_SetHelpString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetHelpString((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_GetAllowList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_GetAllowList" "', argument " "1"" of type '" "lldb::SBBreakpointName const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBreakpointName const *)arg1)->GetAllowList();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetAllowList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_SetAllowList", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetAllowList" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointName_SetAllowList" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAllowList(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_GetAllowDelete(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_GetAllowDelete" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetAllowDelete();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetAllowDelete(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_SetAllowDelete", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetAllowDelete" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointName_SetAllowDelete" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAllowDelete(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_GetAllowDisable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_GetAllowDisable" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetAllowDisable();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_SetAllowDisable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_SetAllowDisable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_SetAllowDisable" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointName_SetAllowDisable" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAllowDisable(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBreakpointName_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName_GetDescription" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointName_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBreakpointName_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBreakpointName___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBreakpointName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBreakpointName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointName___repr__" "', argument " "1"" of type '" "lldb::SBBreakpointName *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBreakpointName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBBreakpointName___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBBreakpointName_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBBreakpointName, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBBreakpointName_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBBroadcaster__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBBroadcaster *)new lldb::SBBroadcaster();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBroadcaster, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBBroadcaster__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  lldb::SBBroadcaster *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBroadcaster" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBBroadcaster *)new lldb::SBBroadcaster((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBroadcaster, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBBroadcaster__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBBroadcaster *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBBroadcaster,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBroadcaster" "', argument " "1"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBBroadcaster" "', argument " "1"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBBroadcaster *)new lldb::SBBroadcaster((lldb::SBBroadcaster const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBroadcaster, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBBroadcaster(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBBroadcaster", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBBroadcaster__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBBroadcaster, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBBroadcaster__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBBroadcaster__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBBroadcaster'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBBroadcaster::SBBroadcaster()\n"
    "    lldb::SBBroadcaster::SBBroadcaster(char const *)\n"
    "    lldb::SBBroadcaster::SBBroadcaster(lldb::SBBroadcaster const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBBroadcaster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBBroadcaster" "', argument " "1"" of type '" "lldb::SBBroadcaster *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBroadcaster___nonzero__" "', argument " "1"" of type '" "lldb::SBBroadcaster const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBroadcaster const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBroadcaster_IsValid" "', argument " "1"" of type '" "lldb::SBBroadcaster const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBroadcaster const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBroadcaster_Clear" "', argument " "1"" of type '" "lldb::SBBroadcaster *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster_BroadcastEventByType__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  uint32_t arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBroadcaster_BroadcastEventByType" "', argument " "1"" of type '" "lldb::SBBroadcaster *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBroadcaster_BroadcastEventByType" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBBroadcaster_BroadcastEventByType" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->BroadcastEventByType(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster_BroadcastEventByType__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBroadcaster_BroadcastEventByType" "', argument " "1"" of type '" "lldb::SBBroadcaster *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBroadcaster_BroadcastEventByType" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->BroadcastEventByType(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster_BroadcastEventByType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBBroadcaster_BroadcastEventByType", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBroadcaster, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBBroadcaster_BroadcastEventByType__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBroadcaster, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBBroadcaster_BroadcastEventByType__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBBroadcaster_BroadcastEventByType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBBroadcaster::BroadcastEventByType(uint32_t,bool)\n"
    "    lldb::SBBroadcaster::BroadcastEventByType(uint32_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster_BroadcastEvent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  lldb::SBEvent *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBroadcaster_BroadcastEvent" "', argument " "1"" of type '" "lldb::SBBroadcaster *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBroadcaster_BroadcastEvent" "', argument " "2"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBroadcaster_BroadcastEvent" "', argument " "2"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBEvent * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBBroadcaster_BroadcastEvent" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->BroadcastEvent((lldb::SBEvent const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster_BroadcastEvent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  lldb::SBEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBroadcaster_BroadcastEvent" "', argument " "1"" of type '" "lldb::SBBroadcaster *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBroadcaster_BroadcastEvent" "', argument " "2"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBroadcaster_BroadcastEvent" "', argument " "2"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBEvent * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->BroadcastEvent((lldb::SBEvent const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster_BroadcastEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBBroadcaster_BroadcastEvent", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBroadcaster, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBBroadcaster_BroadcastEvent__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBroadcaster, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBBroadcaster_BroadcastEvent__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBBroadcaster_BroadcastEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBBroadcaster::BroadcastEvent(lldb::SBEvent const &,bool)\n"
    "    lldb::SBBroadcaster::BroadcastEvent(lldb::SBEvent const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster_AddInitialEventsToListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  lldb::SBListener *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBroadcaster_AddInitialEventsToListener", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBroadcaster_AddInitialEventsToListener" "', argument " "1"" of type '" "lldb::SBBroadcaster *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBListener,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBroadcaster_AddInitialEventsToListener" "', argument " "2"" of type '" "lldb::SBListener const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBroadcaster_AddInitialEventsToListener" "', argument " "2"" of type '" "lldb::SBListener const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBListener * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBBroadcaster_AddInitialEventsToListener" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->AddInitialEventsToListener((lldb::SBListener const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster_AddListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  lldb::SBListener *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBroadcaster_AddListener", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBroadcaster_AddListener" "', argument " "1"" of type '" "lldb::SBBroadcaster *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBListener,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBroadcaster_AddListener" "', argument " "2"" of type '" "lldb::SBListener const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBroadcaster_AddListener" "', argument " "2"" of type '" "lldb::SBListener const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBListener * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBBroadcaster_AddListener" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->AddListener((lldb::SBListener const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBroadcaster_GetName" "', argument " "1"" of type '" "lldb::SBBroadcaster const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBBroadcaster const *)arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster_EventTypeHasListeners(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBroadcaster_EventTypeHasListeners", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBroadcaster_EventTypeHasListeners" "', argument " "1"" of type '" "lldb::SBBroadcaster *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBroadcaster_EventTypeHasListeners" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->EventTypeHasListeners(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster_RemoveListener__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  lldb::SBListener *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBroadcaster_RemoveListener" "', argument " "1"" of type '" "lldb::SBBroadcaster *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBListener,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBroadcaster_RemoveListener" "', argument " "2"" of type '" "lldb::SBListener const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBroadcaster_RemoveListener" "', argument " "2"" of type '" "lldb::SBListener const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBListener * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBBroadcaster_RemoveListener" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->RemoveListener((lldb::SBListener const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster_RemoveListener__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  lldb::SBListener *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBroadcaster_RemoveListener" "', argument " "1"" of type '" "lldb::SBBroadcaster *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBListener,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBroadcaster_RemoveListener" "', argument " "2"" of type '" "lldb::SBListener const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBroadcaster_RemoveListener" "', argument " "2"" of type '" "lldb::SBListener const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBListener * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->RemoveListener((lldb::SBListener const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster_RemoveListener(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBBroadcaster_RemoveListener", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBroadcaster, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBBroadcaster_RemoveListener__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBroadcaster, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBBroadcaster_RemoveListener__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBBroadcaster_RemoveListener'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBBroadcaster::RemoveListener(lldb::SBListener const &,uint32_t)\n"
    "    lldb::SBBroadcaster::RemoveListener(lldb::SBListener const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  lldb::SBBroadcaster *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBroadcaster___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBroadcaster___eq__" "', argument " "1"" of type '" "lldb::SBBroadcaster const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBroadcaster,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBroadcaster___eq__" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBroadcaster___eq__" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBBroadcaster * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBroadcaster const *)arg1)->operator ==((lldb::SBBroadcaster const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  lldb::SBBroadcaster *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBroadcaster___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBroadcaster___ne__" "', argument " "1"" of type '" "lldb::SBBroadcaster const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBroadcaster,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBroadcaster___ne__" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBroadcaster___ne__" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBBroadcaster * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBroadcaster const *)arg1)->operator !=((lldb::SBBroadcaster const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBBroadcaster___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBBroadcaster *arg1 = 0 ;
  lldb::SBBroadcaster *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBBroadcaster___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBBroadcaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBroadcaster___lt__" "', argument " "1"" of type '" "lldb::SBBroadcaster const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBBroadcaster * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBroadcaster,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBroadcaster___lt__" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBBroadcaster___lt__" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBBroadcaster * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBBroadcaster const *)arg1)->operator <((lldb::SBBroadcaster const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *SBBroadcaster_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBBroadcaster, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBBroadcaster_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBCommandInterpreter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBCommandInterpreter *)new lldb::SBCommandInterpreter();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBCommandInterpreter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBCommandInterpreter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBCommandInterpreter *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBCommandInterpreter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBCommandInterpreter" "', argument " "1"" of type '" "lldb::SBCommandInterpreter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBCommandInterpreter" "', argument " "1"" of type '" "lldb::SBCommandInterpreter const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBCommandInterpreter *)new lldb::SBCommandInterpreter((lldb::SBCommandInterpreter const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBCommandInterpreter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBCommandInterpreter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBCommandInterpreter", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBCommandInterpreter__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBCommandInterpreter, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBCommandInterpreter__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBCommandInterpreter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCommandInterpreter::SBCommandInterpreter()\n"
    "    lldb::SBCommandInterpreter::SBCommandInterpreter(lldb::SBCommandInterpreter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBCommandInterpreter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBCommandInterpreter" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetArgumentTypeAsCString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::CommandArgumentType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBCommandInterpreter_GetArgumentTypeAsCString" "', argument " "1"" of type '" "lldb::CommandArgumentType""'");
  } 
  arg1 = static_cast< lldb::CommandArgumentType >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBCommandInterpreter::GetArgumentTypeAsCString(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetArgumentDescriptionAsCString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::CommandArgumentType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBCommandInterpreter_GetArgumentDescriptionAsCString" "', argument " "1"" of type '" "lldb::CommandArgumentType""'");
  } 
  arg1 = static_cast< lldb::CommandArgumentType >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBCommandInterpreter::GetArgumentDescriptionAsCString(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_EventIsCommandInterpreterEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_EventIsCommandInterpreterEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_EventIsCommandInterpreterEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBCommandInterpreter::EventIsCommandInterpreterEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter___nonzero__" "', argument " "1"" of type '" "lldb::SBCommandInterpreter const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommandInterpreter const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_IsValid" "', argument " "1"" of type '" "lldb::SBCommandInterpreter const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommandInterpreter const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_CommandExists(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreter_CommandExists", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_CommandExists" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandInterpreter_CommandExists" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->CommandExists((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_UserCommandExists(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreter_UserCommandExists", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_UserCommandExists" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandInterpreter_UserCommandExists" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->UserCommandExists((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_AliasExists(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreter_AliasExists", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_AliasExists" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandInterpreter_AliasExists" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->AliasExists((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetBroadcaster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBroadcaster result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_GetBroadcaster" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetBroadcaster();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBroadcaster(result)), SWIGTYPE_p_lldb__SBBroadcaster, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetBroadcasterClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreter_GetBroadcasterClass", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBCommandInterpreter::GetBroadcasterClass();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HasCommands(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_HasCommands" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->HasCommands();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HasAliases(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_HasAliases" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->HasAliases();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HasAliasOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_HasAliasOptions" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->HasAliasOptions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_IsInteractive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_IsInteractive" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsInteractive();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBProcess result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_GetProcess" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetProcess();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetDebugger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBDebugger result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_GetDebugger" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetDebugger();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBDebugger(result)), SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  lldb::SBCommandReturnObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_SourceInitFileInHomeDirectory" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBCommandReturnObject,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandInterpreter_SourceInitFileInHomeDirectory" "', argument " "2"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_SourceInitFileInHomeDirectory" "', argument " "2"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SourceInitFileInHomeDirectory(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  lldb::SBCommandReturnObject *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_SourceInitFileInHomeDirectory" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBCommandReturnObject,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandInterpreter_SourceInitFileInHomeDirectory" "', argument " "2"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_SourceInitFileInHomeDirectory" "', argument " "2"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBCommandInterpreter_SourceInitFileInHomeDirectory" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SourceInitFileInHomeDirectory(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBCommandInterpreter_SourceInitFileInHomeDirectory", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandInterpreter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandInterpreter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBCommandInterpreter_SourceInitFileInHomeDirectory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCommandInterpreter::SourceInitFileInHomeDirectory(lldb::SBCommandReturnObject &)\n"
    "    lldb::SBCommandInterpreter::SourceInitFileInHomeDirectory(lldb::SBCommandReturnObject &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  lldb::SBCommandReturnObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBCommandReturnObject,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory" "', argument " "2"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory" "', argument " "2"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SourceInitFileInCurrentWorkingDirectory(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCommand__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBCommandReturnObject *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  lldb::ReturnStatus result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBCommandReturnObject,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "3"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "3"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ReturnStatus)(arg1)->HandleCommand((char const *)arg2,*arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCommand__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBCommandReturnObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::ReturnStatus result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBCommandReturnObject,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "3"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "3"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ReturnStatus)(arg1)->HandleCommand((char const *)arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCommand__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBExecutionContext *arg3 = 0 ;
  lldb::SBCommandReturnObject *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  lldb::ReturnStatus result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBExecutionContext,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "3"" of type '" "lldb::SBExecutionContext &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "3"" of type '" "lldb::SBExecutionContext &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBExecutionContext * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBCommandReturnObject,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "4"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "4"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ReturnStatus)(arg1)->HandleCommand((char const *)arg2,*arg3,*arg4,arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCommand__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBExecutionContext *arg3 = 0 ;
  lldb::SBCommandReturnObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  lldb::ReturnStatus result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBExecutionContext,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "3"" of type '" "lldb::SBExecutionContext &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "3"" of type '" "lldb::SBExecutionContext &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBExecutionContext * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBCommandReturnObject,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "4"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_HandleCommand" "', argument " "4"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ReturnStatus)(arg1)->HandleCommand((char const *)arg2,*arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCommand(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBCommandInterpreter_HandleCommand", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandInterpreter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBCommandInterpreter_HandleCommand__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandInterpreter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBCommandInterpreter_HandleCommand__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandInterpreter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBCommandInterpreter_HandleCommand__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandInterpreter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SBCommandInterpreter_HandleCommand__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBCommandInterpreter_HandleCommand'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCommandInterpreter::HandleCommand(char const *,lldb::SBCommandReturnObject &,bool)\n"
    "    lldb::SBCommandInterpreter::HandleCommand(char const *,lldb::SBCommandReturnObject &)\n"
    "    lldb::SBCommandInterpreter::HandleCommand(char const *,lldb::SBExecutionContext &,lldb::SBCommandReturnObject &,bool)\n"
    "    lldb::SBCommandInterpreter::HandleCommand(char const *,lldb::SBExecutionContext &,lldb::SBCommandReturnObject &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCommandsFromFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  lldb::SBExecutionContext *arg3 = 0 ;
  lldb::SBCommandInterpreterRunOptions *arg4 = 0 ;
  lldb::SBCommandReturnObject arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreter_HandleCommandsFromFile", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_HandleCommandsFromFile" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandInterpreter_HandleCommandsFromFile" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_HandleCommandsFromFile" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBExecutionContext,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBCommandInterpreter_HandleCommandsFromFile" "', argument " "3"" of type '" "lldb::SBExecutionContext &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_HandleCommandsFromFile" "', argument " "3"" of type '" "lldb::SBExecutionContext &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBExecutionContext * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBCommandInterpreter_HandleCommandsFromFile" "', argument " "4"" of type '" "lldb::SBCommandInterpreterRunOptions &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_HandleCommandsFromFile" "', argument " "4"" of type '" "lldb::SBCommandInterpreterRunOptions &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBCommandReturnObject,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBCommandInterpreter_HandleCommandsFromFile" "', argument " "5"" of type '" "lldb::SBCommandReturnObject""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_HandleCommandsFromFile" "', argument " "5"" of type '" "lldb::SBCommandReturnObject""'");
    } else {
      lldb::SBCommandReturnObject * temp = reinterpret_cast< lldb::SBCommandReturnObject * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->HandleCommandsFromFile(*arg2,*arg3,*arg4,SWIG_STD_MOVE(arg5));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCompletion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  int arg4 ;
  int arg5 ;
  lldb::SBStringList *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreter_HandleCompletion", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_HandleCompletion" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandInterpreter_HandleCompletion" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBCommandInterpreter_HandleCompletion" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBCommandInterpreter_HandleCompletion" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBCommandInterpreter_HandleCompletion" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_lldb__SBStringList,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SBCommandInterpreter_HandleCompletion" "', argument " "6"" of type '" "lldb::SBStringList &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_HandleCompletion" "', argument " "6"" of type '" "lldb::SBStringList &""'"); 
  }
  arg6 = reinterpret_cast< lldb::SBStringList * >(argp6);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)(arg1)->HandleCompletion((char const *)arg2,arg3,arg4,arg5,*arg6);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HandleCompletionWithDescriptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  int arg4 ;
  int arg5 ;
  lldb::SBStringList *arg6 = 0 ;
  lldb::SBStringList *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject *swig_obj[7] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreter_HandleCompletionWithDescriptions", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_HandleCompletionWithDescriptions" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandInterpreter_HandleCompletionWithDescriptions" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBCommandInterpreter_HandleCompletionWithDescriptions" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBCommandInterpreter_HandleCompletionWithDescriptions" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBCommandInterpreter_HandleCompletionWithDescriptions" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_lldb__SBStringList,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SBCommandInterpreter_HandleCompletionWithDescriptions" "', argument " "6"" of type '" "lldb::SBStringList &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_HandleCompletionWithDescriptions" "', argument " "6"" of type '" "lldb::SBStringList &""'"); 
  }
  arg6 = reinterpret_cast< lldb::SBStringList * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_lldb__SBStringList,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SBCommandInterpreter_HandleCompletionWithDescriptions" "', argument " "7"" of type '" "lldb::SBStringList &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_HandleCompletionWithDescriptions" "', argument " "7"" of type '" "lldb::SBStringList &""'"); 
  }
  arg7 = reinterpret_cast< lldb::SBStringList * >(argp7);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)(arg1)->HandleCompletionWithDescriptions((char const *)arg2,arg3,arg4,arg5,*arg6,*arg7);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_WasInterrupted(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_WasInterrupted" "', argument " "1"" of type '" "lldb::SBCommandInterpreter const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommandInterpreter const *)arg1)->WasInterrupted();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_InterruptCommand(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_InterruptCommand" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->InterruptCommand();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SetCommandOverrideCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::CommandOverrideCallback arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreter_SetCommandOverrideCallback", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_SetCommandOverrideCallback" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandInterpreter_SetCommandOverrideCallback" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    if (!(swig_obj[2] == Py_None ||
        PyCallable_Check(reinterpret_cast<PyObject *>(swig_obj[2])))) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object or None!");
      SWIG_fail;
    }
    
    // Don't lose the callback reference.
    Py_INCREF(swig_obj[2]);
    arg3 = LLDBSwigPythonCallPythonSBCommandInterpreterSetCommandOverrideCallback;
    arg4 = swig_obj[2];
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetCommandOverrideCallback((char const *)arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_IsActive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_IsActive" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsActive();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetIOHandlerControlSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreter_GetIOHandlerControlSequence", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_GetIOHandlerControlSequence" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandInterpreter_GetIOHandlerControlSequence" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetIOHandlerControlSequence(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetPromptOnQuit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_GetPromptOnQuit" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetPromptOnQuit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SetPromptOnQuit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreter_SetPromptOnQuit", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_SetPromptOnQuit" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandInterpreter_SetPromptOnQuit" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetPromptOnQuit(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_AllowExitCodeOnQuit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreter_AllowExitCodeOnQuit", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_AllowExitCodeOnQuit" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandInterpreter_AllowExitCodeOnQuit" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->AllowExitCodeOnQuit(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_HasCustomQuitExitCode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_HasCustomQuitExitCode" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->HasCustomQuitExitCode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetQuitStatus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_GetQuitStatus" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)(arg1)->GetQuitStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_ResolveCommand(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBCommandReturnObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreter_ResolveCommand", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_ResolveCommand" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandInterpreter_ResolveCommand" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBCommandReturnObject,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBCommandInterpreter_ResolveCommand" "', argument " "3"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandInterpreter_ResolveCommand" "', argument " "3"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->ResolveCommand((char const *)arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetStatistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_GetStatistics" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetStatistics();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_GetTranscript(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_GetTranscript" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTranscript();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreter_SetPrintCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreter *arg1 = 0 ;
  lldb::SBCommandPrintCallback arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreter_SetPrintCallback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreter_SetPrintCallback" "', argument " "1"" of type '" "lldb::SBCommandInterpreter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreter * >(argp1);
  {
    if (!(swig_obj[1] == Py_None ||
        PyCallable_Check(reinterpret_cast<PyObject *>(swig_obj[1])))) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object or None!");
      SWIG_fail;
    }
    
    // Don't lose the callback reference.
    Py_INCREF(swig_obj[1]);
    arg2 = LLDBSwigPythonCallPythonCommandPrintCallback;
    arg3 = swig_obj[1];
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetPrintCallback(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBCommandInterpreter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBCommandInterpreter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBCommandInterpreter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBCommandInterpreterRunOptions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBCommandInterpreterRunOptions *)new lldb::SBCommandInterpreterRunOptions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBCommandInterpreterRunOptions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBCommandInterpreterRunOptions *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBCommandInterpreterRunOptions" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBCommandInterpreterRunOptions" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBCommandInterpreterRunOptions *)new lldb::SBCommandInterpreterRunOptions((lldb::SBCommandInterpreterRunOptions const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBCommandInterpreterRunOptions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBCommandInterpreterRunOptions", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBCommandInterpreterRunOptions__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBCommandInterpreterRunOptions__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBCommandInterpreterRunOptions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions()\n"
    "    lldb::SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions(lldb::SBCommandInterpreterRunOptions const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBCommandInterpreterRunOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBCommandInterpreterRunOptions" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetStopOnContinue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_GetStopOnContinue" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetStopOnContinue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetStopOnContinue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreterRunOptions_SetStopOnContinue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_SetStopOnContinue" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandInterpreterRunOptions_SetStopOnContinue" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetStopOnContinue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetStopOnError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_GetStopOnError" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetStopOnError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetStopOnError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreterRunOptions_SetStopOnError", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_SetStopOnError" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandInterpreterRunOptions_SetStopOnError" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetStopOnError(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetStopOnCrash(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_GetStopOnCrash" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetStopOnCrash();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetStopOnCrash(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreterRunOptions_SetStopOnCrash", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_SetStopOnCrash" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandInterpreterRunOptions_SetStopOnCrash" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetStopOnCrash(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetEchoCommands(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_GetEchoCommands" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetEchoCommands();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetEchoCommands(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreterRunOptions_SetEchoCommands", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_SetEchoCommands" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandInterpreterRunOptions_SetEchoCommands" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetEchoCommands(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetEchoCommentCommands(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_GetEchoCommentCommands" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetEchoCommentCommands();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetEchoCommentCommands(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreterRunOptions_SetEchoCommentCommands", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_SetEchoCommentCommands" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandInterpreterRunOptions_SetEchoCommentCommands" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetEchoCommentCommands(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetPrintResults(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_GetPrintResults" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetPrintResults();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetPrintResults(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreterRunOptions_SetPrintResults", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_SetPrintResults" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandInterpreterRunOptions_SetPrintResults" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetPrintResults(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetPrintErrors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_GetPrintErrors" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetPrintErrors();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetPrintErrors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreterRunOptions_SetPrintErrors", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_SetPrintErrors" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandInterpreterRunOptions_SetPrintErrors" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetPrintErrors(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetAddToHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_GetAddToHistory" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetAddToHistory();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetAddToHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreterRunOptions_SetAddToHistory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_SetAddToHistory" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandInterpreterRunOptions_SetAddToHistory" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAddToHistory(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetAutoHandleEvents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_GetAutoHandleEvents" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetAutoHandleEvents();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetAutoHandleEvents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreterRunOptions_SetAutoHandleEvents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_SetAutoHandleEvents" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandInterpreterRunOptions_SetAutoHandleEvents" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAutoHandleEvents(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetSpawnThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_GetSpawnThread" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetSpawnThread();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetSpawnThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreterRunOptions_SetSpawnThread", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_SetSpawnThread" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandInterpreterRunOptions_SetSpawnThread" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetSpawnThread(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_GetAllowRepeats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_GetAllowRepeats" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetAllowRepeats();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandInterpreterRunOptions_SetAllowRepeats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandInterpreterRunOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandInterpreterRunOptions_SetAllowRepeats", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandInterpreterRunOptions_SetAllowRepeats" "', argument " "1"" of type '" "lldb::SBCommandInterpreterRunOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandInterpreterRunOptions_SetAllowRepeats" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAllowRepeats(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBCommandInterpreterRunOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBCommandInterpreterRunOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBCommandReturnObject__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBCommandReturnObject *)new lldb::SBCommandReturnObject();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBCommandReturnObject__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBCommandReturnObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBCommandReturnObject,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBCommandReturnObject" "', argument " "1"" of type '" "lldb::SBCommandReturnObject const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBCommandReturnObject" "', argument " "1"" of type '" "lldb::SBCommandReturnObject const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBCommandReturnObject *)new lldb::SBCommandReturnObject((lldb::SBCommandReturnObject const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBCommandReturnObject(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBCommandReturnObject", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBCommandReturnObject__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBCommandReturnObject__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBCommandReturnObject'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCommandReturnObject::SBCommandReturnObject()\n"
    "    lldb::SBCommandReturnObject::SBCommandReturnObject(lldb::SBCommandReturnObject const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBCommandReturnObject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBCommandReturnObject" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject___nonzero__" "', argument " "1"" of type '" "lldb::SBCommandReturnObject const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommandReturnObject const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_IsValid" "', argument " "1"" of type '" "lldb::SBCommandReturnObject const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommandReturnObject const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetCommand(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_GetCommand" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetCommand();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetOutput__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_GetOutput" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetOutput();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_GetError" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetErrorData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_GetErrorData" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetErrorData();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutOutput__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  lldb::SBFile arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_PutOutput" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFile,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandReturnObject_PutOutput" "', argument " "2"" of type '" "lldb::SBFile""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandReturnObject_PutOutput" "', argument " "2"" of type '" "lldb::SBFile""'");
    } else {
      lldb::SBFile * temp = reinterpret_cast< lldb::SBFile * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->PutOutput(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutOutput__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_PutOutput" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[1]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp =
    unwrapOrSetPythonException(py_file.ConvertToFile(/*borrowed=*/true));
    if (!sp)
    SWIG_fail;
    arg2 = sp;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->PutOutput(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutOutput(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBCommandReturnObject_PutOutput", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBCommandReturnObject_PutOutput__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        if (PythonFile::Check(argv[1])) {
          _v = 1;
        } else {
          PyErr_Clear();
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SBCommandReturnObject_PutOutput__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBCommandReturnObject_PutOutput'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCommandReturnObject::PutOutput(lldb::SBFile)\n"
    "    lldb::SBCommandReturnObject::PutOutput(lldb::FileSP)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetOutputSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_GetOutputSize" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetOutputSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetErrorSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_GetErrorSize" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetErrorSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  lldb::SBFile arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_PutError" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFile,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandReturnObject_PutError" "', argument " "2"" of type '" "lldb::SBFile""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandReturnObject_PutError" "', argument " "2"" of type '" "lldb::SBFile""'");
    } else {
      lldb::SBFile * temp = reinterpret_cast< lldb::SBFile * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->PutError(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_PutError" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[1]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp =
    unwrapOrSetPythonException(py_file.ConvertToFile(/*borrowed=*/true));
    if (!sp)
    SWIG_fail;
    arg2 = sp;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->PutError(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBCommandReturnObject_PutError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBCommandReturnObject_PutError__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        if (PythonFile::Check(argv[1])) {
          _v = 1;
        } else {
          PyErr_Clear();
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SBCommandReturnObject_PutError__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBCommandReturnObject_PutError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCommandReturnObject::PutError(lldb::SBFile)\n"
    "    lldb::SBCommandReturnObject::PutError(lldb::FileSP)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_Clear" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetStatus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::ReturnStatus result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_GetStatus" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ReturnStatus)(arg1)->GetStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetStatus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  lldb::ReturnStatus arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandReturnObject_SetStatus", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_SetStatus" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandReturnObject_SetStatus" "', argument " "2"" of type '" "lldb::ReturnStatus""'");
  } 
  arg2 = static_cast< lldb::ReturnStatus >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetStatus(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_Succeeded(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_Succeeded" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->Succeeded();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_HasResult(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_HasResult" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->HasResult();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_AppendMessage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandReturnObject_AppendMessage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_AppendMessage" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandReturnObject_AppendMessage" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->AppendMessage((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_AppendWarning(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandReturnObject_AppendWarning", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_AppendWarning" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandReturnObject_AppendWarning" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->AppendWarning((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandReturnObject_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_GetDescription" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandReturnObject_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandReturnObject_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  lldb::SBFile arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_SetImmediateOutputFile" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFile,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandReturnObject_SetImmediateOutputFile" "', argument " "2"" of type '" "lldb::SBFile""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandReturnObject_SetImmediateOutputFile" "', argument " "2"" of type '" "lldb::SBFile""'");
    } else {
      lldb::SBFile * temp = reinterpret_cast< lldb::SBFile * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetImmediateOutputFile(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  lldb::SBFile arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_SetImmediateErrorFile" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFile,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandReturnObject_SetImmediateErrorFile" "', argument " "2"" of type '" "lldb::SBFile""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandReturnObject_SetImmediateErrorFile" "', argument " "2"" of type '" "lldb::SBFile""'");
    } else {
      lldb::SBFile * temp = reinterpret_cast< lldb::SBFile * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetImmediateErrorFile(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_SetImmediateOutputFile" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[1]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp =
    unwrapOrSetPythonException(py_file.ConvertToFile(/*borrowed=*/true));
    if (!sp)
    SWIG_fail;
    arg2 = sp;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetImmediateOutputFile(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_SetImmediateErrorFile" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[1]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp =
    unwrapOrSetPythonException(py_file.ConvertToFile(/*borrowed=*/true));
    if (!sp)
    SWIG_fail;
    arg2 = sp;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetImmediateErrorFile(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutCString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_PutCString" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    if (swig_obj[1] == Py_None) {
      arg2 = NULL;
      arg3 = 0;
    } else if (PythonString::Check(swig_obj[1])) {
      PythonString py_str(PyRefType::Borrowed, swig_obj[1]);
      llvm::StringRef str = py_str.GetString();
      arg2 = const_cast<char *>(str.data());
      arg3 = str.size();
      // In Python 2, if swig_obj[1] is a PyUnicode object then this
      // will trigger a Unicode -> String conversion, in which
      // case the `PythonString` will now own the PyString.  Thus
      // if it goes out of scope, the data will be deleted.  The
      // only way to avoid this is to leak the Python object in
      // that case.  Note that if there was no conversion, then
      // releasing the string will not leak anything, since we
      // created this as a borrowed reference.
      py_str.release();
    } else {
      PyErr_SetString(PyExc_TypeError, "not a string-like object");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->PutCString((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutCString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_PutCString" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandReturnObject_PutCString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->PutCString((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_PutCString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBCommandReturnObject_PutCString", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_SBCommandReturnObject_PutCString__SWIG_0(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBCommandReturnObject_PutCString__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBCommandReturnObject_PutCString__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBCommandReturnObject_PutCString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCommandReturnObject::PutCString(char const *,int)\n"
    "    lldb::SBCommandReturnObject::PutCString(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetOutput__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_GetOutput" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandReturnObject_GetOutput" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetOutput(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetOutput(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBCommandReturnObject_GetOutput", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBCommandReturnObject_GetOutput__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBCommandReturnObject_GetOutput__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBCommandReturnObject_GetOutput'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCommandReturnObject::GetOutput()\n"
    "    lldb::SBCommandReturnObject::GetOutput(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_GetError" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandReturnObject_GetError" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetError(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBCommandReturnObject_GetError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBCommandReturnObject_GetError__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBCommandReturnObject_GetError__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBCommandReturnObject_GetError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCommandReturnObject::GetError()\n"
    "    lldb::SBCommandReturnObject::GetError(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_SetError" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandReturnObject_SetError" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandReturnObject_SetError" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBCommandReturnObject_SetError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetError(*arg2,(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_SetError" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandReturnObject_SetError" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommandReturnObject_SetError" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetError(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_SetError" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandReturnObject_SetError" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetError((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBCommandReturnObject_SetError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBCommandReturnObject_SetError__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBCommandReturnObject_SetError__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBCommandReturnObject_SetError__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBCommandReturnObject_SetError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCommandReturnObject::SetError(lldb::SBError &,char const *)\n"
    "    lldb::SBCommandReturnObject::SetError(lldb::SBError &)\n"
    "    lldb::SBCommandReturnObject::SetError(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_GetValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  lldb::DynamicValueType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBValueList result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandReturnObject_GetValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_GetValues" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommandReturnObject_GetValues" "', argument " "2"" of type '" "lldb::DynamicValueType""'");
  } 
  arg2 = static_cast< lldb::DynamicValueType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetValues(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValueList(result)), SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject___repr__" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBCommandReturnObject___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_SetImmediateOutputFile" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[1]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp =
    unwrapOrSetPythonException(py_file.ConvertToFile(/*borrowed=*/true));
    if (!sp)
    SWIG_fail;
    arg2 = sp;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBCommandReturnObject_SetImmediateOutputFile" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb_SBCommandReturnObject_SetImmediateOutputFile__SWIG_2(arg1,SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateOutputFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBCommandReturnObject_SetImmediateOutputFile", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        if (PythonFile::Check(argv[1])) {
          _v = 1;
        } else {
          PyErr_Clear();
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        if (PythonFile::Check(argv[1])) {
          _v = 1;
        } else {
          PyErr_Clear();
          _v = 0;
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBCommandReturnObject_SetImmediateOutputFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCommandReturnObject::SetImmediateOutputFile(lldb::SBFile)\n"
    "    lldb::SBCommandReturnObject::SetImmediateOutputFile(lldb::FileSP)\n"
    "    lldb::SBCommandReturnObject::SetImmediateOutputFile(lldb::FileSP,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_SetImmediateErrorFile" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[1]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp =
    unwrapOrSetPythonException(py_file.ConvertToFile(/*borrowed=*/true));
    if (!sp)
    SWIG_fail;
    arg2 = sp;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBCommandReturnObject_SetImmediateErrorFile" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb_SBCommandReturnObject_SetImmediateErrorFile__SWIG_2(arg1,SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_SetImmediateErrorFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBCommandReturnObject_SetImmediateErrorFile", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        if (PythonFile::Check(argv[1])) {
          _v = 1;
        } else {
          PyErr_Clear();
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        if (PythonFile::Check(argv[1])) {
          _v = 1;
        } else {
          PyErr_Clear();
          _v = 0;
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBCommandReturnObject_SetImmediateErrorFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCommandReturnObject::SetImmediateErrorFile(lldb::SBFile)\n"
    "    lldb::SBCommandReturnObject::SetImmediateErrorFile(lldb::FileSP)\n"
    "    lldb::SBCommandReturnObject::SetImmediateErrorFile(lldb::FileSP,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_Print(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandReturnObject_Print", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_Print" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandReturnObject_Print" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb_SBCommandReturnObject_Print(arg1,(char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommandReturnObject_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_write" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommandReturnObject_write" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb_SBCommandReturnObject_write(arg1,(char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommandReturnObject_flush(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommandReturnObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommandReturnObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommandReturnObject_flush" "', argument " "1"" of type '" "lldb::SBCommandReturnObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb_SBCommandReturnObject_flush(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBCommandReturnObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBCommandReturnObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBCommunication__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBCommunication *)new lldb::SBCommunication();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBCommunication, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBCommunication__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  lldb::SBCommunication *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBCommunication" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBCommunication *)new lldb::SBCommunication((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBCommunication, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBCommunication(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBCommunication", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBCommunication__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBCommunication__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBCommunication'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCommunication::SBCommunication()\n"
    "    lldb::SBCommunication::SBCommunication(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBCommunication(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommunication, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBCommunication" "', argument " "1"" of type '" "lldb::SBCommunication *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommunication * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommunication___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommunication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommunication___nonzero__" "', argument " "1"" of type '" "lldb::SBCommunication const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommunication * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommunication const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommunication_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommunication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommunication_IsValid" "', argument " "1"" of type '" "lldb::SBCommunication const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommunication * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommunication const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommunication_GetBroadcaster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBroadcaster result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommunication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommunication_GetBroadcaster" "', argument " "1"" of type '" "lldb::SBCommunication *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommunication * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetBroadcaster();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBroadcaster(result)), SWIGTYPE_p_lldb__SBBroadcaster, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommunication_GetBroadcasterClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommunication_GetBroadcasterClass", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBCommunication::GetBroadcasterClass();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommunication_AdoptFileDesriptor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *arg1 = 0 ;
  int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::ConnectionStatus result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommunication_AdoptFileDesriptor", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommunication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommunication_AdoptFileDesriptor" "', argument " "1"" of type '" "lldb::SBCommunication *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommunication * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommunication_AdoptFileDesriptor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBCommunication_AdoptFileDesriptor" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ConnectionStatus)(arg1)->AdoptFileDesriptor(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommunication_Connect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::ConnectionStatus result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommunication_Connect", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommunication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommunication_Connect" "', argument " "1"" of type '" "lldb::SBCommunication *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommunication * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommunication_Connect" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ConnectionStatus)(arg1)->Connect((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommunication_Disconnect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::ConnectionStatus result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommunication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommunication_Disconnect" "', argument " "1"" of type '" "lldb::SBCommunication *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommunication * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ConnectionStatus)(arg1)->Disconnect();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommunication_IsConnected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommunication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommunication_IsConnected" "', argument " "1"" of type '" "lldb::SBCommunication const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommunication * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCommunication const *)arg1)->IsConnected();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommunication_GetCloseOnEOF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommunication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommunication_GetCloseOnEOF" "', argument " "1"" of type '" "lldb::SBCommunication *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommunication * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetCloseOnEOF();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommunication_SetCloseOnEOF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommunication_SetCloseOnEOF", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommunication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommunication_SetCloseOnEOF" "', argument " "1"" of type '" "lldb::SBCommunication *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommunication * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCommunication_SetCloseOnEOF" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetCloseOnEOF(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommunication_Read(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *arg1 = 0 ;
  void *arg2 = 0 ;
  size_t arg3 ;
  uint32_t arg4 ;
  lldb::ConnectionStatus *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommunication_Read", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommunication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommunication_Read" "', argument " "1"" of type '" "lldb::SBCommunication *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommunication * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommunication_Read" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBCommunication_Read" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBCommunication_Read" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__ConnectionStatus,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBCommunication_Read" "', argument " "5"" of type '" "lldb::ConnectionStatus &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommunication_Read" "', argument " "5"" of type '" "lldb::ConnectionStatus &""'"); 
  }
  arg5 = reinterpret_cast< lldb::ConnectionStatus * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Read(arg2,SWIG_STD_MOVE(arg3),arg4,*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommunication_Write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *arg1 = 0 ;
  void *arg2 = 0 ;
  size_t arg3 ;
  lldb::ConnectionStatus *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommunication_Write", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommunication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommunication_Write" "', argument " "1"" of type '" "lldb::SBCommunication *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommunication * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCommunication_Write" "', argument " "2"" of type '" "void const *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBCommunication_Write" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__ConnectionStatus,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBCommunication_Write" "', argument " "4"" of type '" "lldb::ConnectionStatus &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCommunication_Write" "', argument " "4"" of type '" "lldb::ConnectionStatus &""'"); 
  }
  arg4 = reinterpret_cast< lldb::ConnectionStatus * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Write((void const *)arg2,SWIG_STD_MOVE(arg3),*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommunication_ReadThreadStart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommunication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommunication_ReadThreadStart" "', argument " "1"" of type '" "lldb::SBCommunication *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommunication * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->ReadThreadStart();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommunication_ReadThreadStop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommunication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommunication_ReadThreadStop" "', argument " "1"" of type '" "lldb::SBCommunication *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommunication * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->ReadThreadStop();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommunication_ReadThreadIsRunning(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommunication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommunication_ReadThreadIsRunning" "', argument " "1"" of type '" "lldb::SBCommunication *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommunication * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->ReadThreadIsRunning();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCommunication_SetReadThreadBytesReceivedCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCommunication *arg1 = 0 ;
  lldb::SBCommunication::ReadThreadBytesReceived arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCommunication_SetReadThreadBytesReceivedCallback", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCommunication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCommunication_SetReadThreadBytesReceivedCallback" "', argument " "1"" of type '" "lldb::SBCommunication *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCommunication * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__void_size_t__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SBCommunication_SetReadThreadBytesReceivedCallback" "', argument " "2"" of type '" "lldb::SBCommunication::ReadThreadBytesReceived""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBCommunication_SetReadThreadBytesReceivedCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetReadThreadBytesReceivedCallback(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBCommunication_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBCommunication, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBCommunication_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBCompileUnit__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBCompileUnit *)new lldb::SBCompileUnit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBCompileUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBCompileUnit__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBCompileUnit *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBCompileUnit,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBCompileUnit" "', argument " "1"" of type '" "lldb::SBCompileUnit const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBCompileUnit" "', argument " "1"" of type '" "lldb::SBCompileUnit const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBCompileUnit *)new lldb::SBCompileUnit((lldb::SBCompileUnit const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBCompileUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBCompileUnit(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBCompileUnit", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBCompileUnit__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBCompileUnit, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBCompileUnit__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBCompileUnit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCompileUnit::SBCompileUnit()\n"
    "    lldb::SBCompileUnit::SBCompileUnit(lldb::SBCompileUnit const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBCompileUnit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBCompileUnit" "', argument " "1"" of type '" "lldb::SBCompileUnit *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit___nonzero__" "', argument " "1"" of type '" "lldb::SBCompileUnit const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCompileUnit const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit_IsValid" "', argument " "1"" of type '" "lldb::SBCompileUnit const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCompileUnit const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_GetFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit_GetFileSpec" "', argument " "1"" of type '" "lldb::SBCompileUnit const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBCompileUnit const *)arg1)->GetFileSpec();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_GetNumLineEntries(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit_GetNumLineEntries" "', argument " "1"" of type '" "lldb::SBCompileUnit const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBCompileUnit const *)arg1)->GetNumLineEntries();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_GetLineEntryAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBLineEntry result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCompileUnit_GetLineEntryAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit_GetLineEntryAtIndex" "', argument " "1"" of type '" "lldb::SBCompileUnit const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCompileUnit_GetLineEntryAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBCompileUnit const *)arg1)->GetLineEntryAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBLineEntry(result)), SWIGTYPE_p_lldb__SBLineEntry, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_FindLineEntryIndex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  lldb::SBLineEntry *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  uint32_t result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit_FindLineEntryIndex" "', argument " "1"" of type '" "lldb::SBCompileUnit const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBLineEntry,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCompileUnit_FindLineEntryIndex" "', argument " "2"" of type '" "lldb::SBLineEntry &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCompileUnit_FindLineEntryIndex" "', argument " "2"" of type '" "lldb::SBLineEntry &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBLineEntry * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBCompileUnit_FindLineEntryIndex" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBCompileUnit const *)arg1)->FindLineEntryIndex(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_FindLineEntryIndex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  lldb::SBLineEntry *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  uint32_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit_FindLineEntryIndex" "', argument " "1"" of type '" "lldb::SBCompileUnit const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBLineEntry,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCompileUnit_FindLineEntryIndex" "', argument " "2"" of type '" "lldb::SBLineEntry &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCompileUnit_FindLineEntryIndex" "', argument " "2"" of type '" "lldb::SBLineEntry &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBLineEntry * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBCompileUnit const *)arg1)->FindLineEntryIndex(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_FindLineEntryIndex__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  lldb::SBFileSpec *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  uint32_t result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit_FindLineEntryIndex" "', argument " "1"" of type '" "lldb::SBCompileUnit const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCompileUnit_FindLineEntryIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBCompileUnit_FindLineEntryIndex" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_lldb__SBFileSpec, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBCompileUnit_FindLineEntryIndex" "', argument " "4"" of type '" "lldb::SBFileSpec *""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBFileSpec * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBCompileUnit const *)arg1)->FindLineEntryIndex(arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_FindLineEntryIndex__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  lldb::SBFileSpec *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  uint32_t result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit_FindLineEntryIndex" "', argument " "1"" of type '" "lldb::SBCompileUnit const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCompileUnit_FindLineEntryIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBCompileUnit_FindLineEntryIndex" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_lldb__SBFileSpec, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBCompileUnit_FindLineEntryIndex" "', argument " "4"" of type '" "lldb::SBFileSpec *""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBFileSpec * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBCompileUnit_FindLineEntryIndex" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBCompileUnit const *)arg1)->FindLineEntryIndex(arg2,arg3,arg4,arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_FindLineEntryIndex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBCompileUnit_FindLineEntryIndex", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCompileUnit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBLineEntry, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBCompileUnit_FindLineEntryIndex__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCompileUnit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBLineEntry, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBCompileUnit_FindLineEntryIndex__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCompileUnit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_lldb__SBFileSpec, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBCompileUnit_FindLineEntryIndex__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCompileUnit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_lldb__SBFileSpec, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SBCompileUnit_FindLineEntryIndex__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBCompileUnit_FindLineEntryIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCompileUnit::FindLineEntryIndex(lldb::SBLineEntry &,bool) const\n"
    "    lldb::SBCompileUnit::FindLineEntryIndex(lldb::SBLineEntry &) const\n"
    "    lldb::SBCompileUnit::FindLineEntryIndex(uint32_t,uint32_t,lldb::SBFileSpec *) const\n"
    "    lldb::SBCompileUnit::FindLineEntryIndex(uint32_t,uint32_t,lldb::SBFileSpec *,bool) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_GetSupportFileAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCompileUnit_GetSupportFileAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit_GetSupportFileAtIndex" "', argument " "1"" of type '" "lldb::SBCompileUnit const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCompileUnit_GetSupportFileAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBCompileUnit const *)arg1)->GetSupportFileAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_GetNumSupportFiles(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit_GetNumSupportFiles" "', argument " "1"" of type '" "lldb::SBCompileUnit const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBCompileUnit const *)arg1)->GetNumSupportFiles();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_FindSupportFileIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  uint32_t arg2 ;
  lldb::SBFileSpec *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCompileUnit_FindSupportFileIndex", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit_FindSupportFileIndex" "', argument " "1"" of type '" "lldb::SBCompileUnit *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCompileUnit_FindSupportFileIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBCompileUnit_FindSupportFileIndex" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCompileUnit_FindSupportFileIndex" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpec * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBCompileUnit_FindSupportFileIndex" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->FindSupportFileIndex(arg2,(lldb::SBFileSpec const &)*arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_GetTypes__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  lldb::SBTypeList result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit_GetTypes" "', argument " "1"" of type '" "lldb::SBCompileUnit *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBCompileUnit_GetTypes" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTypes(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeList(result)), SWIGTYPE_p_lldb__SBTypeList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_GetTypes__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBTypeList result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit_GetTypes" "', argument " "1"" of type '" "lldb::SBCompileUnit *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTypes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeList(result)), SWIGTYPE_p_lldb__SBTypeList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_GetTypes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBCompileUnit_GetTypes", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCompileUnit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBCompileUnit_GetTypes__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBCompileUnit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBCompileUnit_GetTypes__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBCompileUnit_GetTypes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBCompileUnit::GetTypes(uint32_t)\n"
    "    lldb::SBCompileUnit::GetTypes()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_GetLanguage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::LanguageType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit_GetLanguage" "', argument " "1"" of type '" "lldb::SBCompileUnit *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::LanguageType)(arg1)->GetLanguage();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  lldb::SBCompileUnit *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCompileUnit___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit___eq__" "', argument " "1"" of type '" "lldb::SBCompileUnit const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBCompileUnit,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCompileUnit___eq__" "', argument " "2"" of type '" "lldb::SBCompileUnit const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCompileUnit___eq__" "', argument " "2"" of type '" "lldb::SBCompileUnit const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBCompileUnit * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCompileUnit const *)arg1)->operator ==((lldb::SBCompileUnit const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  lldb::SBCompileUnit *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCompileUnit___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit___ne__" "', argument " "1"" of type '" "lldb::SBCompileUnit const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBCompileUnit,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCompileUnit___ne__" "', argument " "2"" of type '" "lldb::SBCompileUnit const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCompileUnit___ne__" "', argument " "2"" of type '" "lldb::SBCompileUnit const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBCompileUnit * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBCompileUnit const *)arg1)->operator !=((lldb::SBCompileUnit const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBCompileUnit_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit_GetDescription" "', argument " "1"" of type '" "lldb::SBCompileUnit *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBCompileUnit_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBCompileUnit_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBCompileUnit___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBCompileUnit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBCompileUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBCompileUnit___repr__" "', argument " "1"" of type '" "lldb::SBCompileUnit *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBCompileUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBCompileUnit___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBCompileUnit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBCompileUnit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBCompileUnit_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBSaveCoreOptions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBSaveCoreOptions *)new lldb::SBSaveCoreOptions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBSaveCoreOptions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBSaveCoreOptions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBSaveCoreOptions *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBSaveCoreOptions,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBSaveCoreOptions" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBSaveCoreOptions" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBSaveCoreOptions *)new lldb::SBSaveCoreOptions((lldb::SBSaveCoreOptions const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBSaveCoreOptions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBSaveCoreOptions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBSaveCoreOptions", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBSaveCoreOptions__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBSaveCoreOptions, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBSaveCoreOptions__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBSaveCoreOptions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBSaveCoreOptions::SBSaveCoreOptions()\n"
    "    lldb::SBSaveCoreOptions::SBSaveCoreOptions(lldb::SBSaveCoreOptions const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBSaveCoreOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSaveCoreOptions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBSaveCoreOptions" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_SetPluginName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSaveCoreOptions_SetPluginName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSaveCoreOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSaveCoreOptions_SetPluginName" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSaveCoreOptions_SetPluginName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetPluginName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetPluginName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSaveCoreOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSaveCoreOptions_GetPluginName" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBSaveCoreOptions const *)arg1)->GetPluginName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_SetStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  lldb::SaveCoreStyle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSaveCoreOptions_SetStyle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSaveCoreOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSaveCoreOptions_SetStyle" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBSaveCoreOptions_SetStyle" "', argument " "2"" of type '" "lldb::SaveCoreStyle""'");
  } 
  arg2 = static_cast< lldb::SaveCoreStyle >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetStyle(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SaveCoreStyle result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSaveCoreOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSaveCoreOptions_GetStyle" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SaveCoreStyle)((lldb::SBSaveCoreOptions const *)arg1)->GetStyle();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_SetOutputFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  lldb::SBFileSpec arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSaveCoreOptions_SetOutputFile", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSaveCoreOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSaveCoreOptions_SetOutputFile" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSaveCoreOptions_SetOutputFile" "', argument " "2"" of type '" "lldb::SBFileSpec""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSaveCoreOptions_SetOutputFile" "', argument " "2"" of type '" "lldb::SBFileSpec""'");
    } else {
      lldb::SBFileSpec * temp = reinterpret_cast< lldb::SBFileSpec * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetOutputFile(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetOutputFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSaveCoreOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSaveCoreOptions_GetOutputFile" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBSaveCoreOptions const *)arg1)->GetOutputFile();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_SetProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  lldb::SBProcess arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSaveCoreOptions_SetProcess", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSaveCoreOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSaveCoreOptions_SetProcess" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBProcess,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSaveCoreOptions_SetProcess" "', argument " "2"" of type '" "lldb::SBProcess""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSaveCoreOptions_SetProcess" "', argument " "2"" of type '" "lldb::SBProcess""'");
    } else {
      lldb::SBProcess * temp = reinterpret_cast< lldb::SBProcess * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetProcess(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBProcess result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSaveCoreOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSaveCoreOptions_GetProcess" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBSaveCoreOptions const *)arg1)->GetProcess();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_AddThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  lldb::SBThread arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSaveCoreOptions_AddThread", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSaveCoreOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSaveCoreOptions_AddThread" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBThread,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSaveCoreOptions_AddThread" "', argument " "2"" of type '" "lldb::SBThread""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSaveCoreOptions_AddThread" "', argument " "2"" of type '" "lldb::SBThread""'");
    } else {
      lldb::SBThread * temp = reinterpret_cast< lldb::SBThread * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->AddThread(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_RemoveThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  lldb::SBThread arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSaveCoreOptions_RemoveThread", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSaveCoreOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSaveCoreOptions_RemoveThread" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBThread,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSaveCoreOptions_RemoveThread" "', argument " "2"" of type '" "lldb::SBThread""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSaveCoreOptions_RemoveThread" "', argument " "2"" of type '" "lldb::SBThread""'");
    } else {
      lldb::SBThread * temp = reinterpret_cast< lldb::SBThread * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->RemoveThread(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_AddMemoryRegionToSave(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  lldb::SBMemoryRegionInfo *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSaveCoreOptions_AddMemoryRegionToSave", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSaveCoreOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSaveCoreOptions_AddMemoryRegionToSave" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBMemoryRegionInfo,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSaveCoreOptions_AddMemoryRegionToSave" "', argument " "2"" of type '" "lldb::SBMemoryRegionInfo const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSaveCoreOptions_AddMemoryRegionToSave" "', argument " "2"" of type '" "lldb::SBMemoryRegionInfo const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->AddMemoryRegionToSave((lldb::SBMemoryRegionInfo const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetThreadsToSave(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBThreadCollection result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSaveCoreOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSaveCoreOptions_GetThreadsToSave" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBSaveCoreOptions const *)arg1)->GetThreadsToSave();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThreadCollection(result)), SWIGTYPE_p_lldb__SBThreadCollection, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetMemoryRegionsToSave(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBMemoryRegionInfoList result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSaveCoreOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSaveCoreOptions_GetMemoryRegionsToSave" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBSaveCoreOptions const *)arg1)->GetMemoryRegionsToSave();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBMemoryRegionInfoList(result)), SWIGTYPE_p_lldb__SBMemoryRegionInfoList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_GetCurrentSizeInBytes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  uint64_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSaveCoreOptions_GetCurrentSizeInBytes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSaveCoreOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSaveCoreOptions_GetCurrentSizeInBytes" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSaveCoreOptions_GetCurrentSizeInBytes" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSaveCoreOptions_GetCurrentSizeInBytes" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetCurrentSizeInBytes(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSaveCoreOptions_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSaveCoreOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSaveCoreOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSaveCoreOptions_Clear" "', argument " "1"" of type '" "lldb::SBSaveCoreOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBSaveCoreOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBSaveCoreOptions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBSaveCoreOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBData__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBData *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBData *)new lldb::SBData();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBData__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBData *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBData,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBData" "', argument " "1"" of type '" "lldb::SBData const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBData" "', argument " "1"" of type '" "lldb::SBData const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBData *)new lldb::SBData((lldb::SBData const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBData", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBData__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBData, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBData__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBData::SBData()\n"
    "    lldb::SBData::SBData(lldb::SBData const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBData" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetAddressByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint8_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetAddressByteSize" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint8_t)(arg1)->GetAddressByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_SetAddressByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_SetAddressByteSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_SetAddressByteSize" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBData_SetAddressByteSize" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = static_cast< uint8_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAddressByteSize(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_Clear" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData___nonzero__" "', argument " "1"" of type '" "lldb::SBData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBData const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_IsValid" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetByteSize" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetByteOrder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::ByteOrder result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetByteOrder" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ByteOrder)(arg1)->GetByteOrder();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_SetByteOrder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::ByteOrder arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_SetByteOrder", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_SetByteOrder" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBData_SetByteOrder" "', argument " "2"" of type '" "lldb::ByteOrder""'");
  } 
  arg2 = static_cast< lldb::ByteOrder >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetByteOrder(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetFloat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::offset_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_GetFloat", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetFloat" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_GetFloat" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_GetFloat" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBData_GetFloat" "', argument " "3"" of type '" "lldb::offset_t""'");
  } 
  arg3 = static_cast< lldb::offset_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (float)(arg1)->GetFloat(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetDouble(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::offset_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_GetDouble", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetDouble" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_GetDouble" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_GetDouble" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBData_GetDouble" "', argument " "3"" of type '" "lldb::offset_t""'");
  } 
  arg3 = static_cast< lldb::offset_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (double)(arg1)->GetDouble(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetLongDouble(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::offset_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  long double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_GetLongDouble", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetLongDouble" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_GetLongDouble" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_GetLongDouble" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBData_GetLongDouble" "', argument " "3"" of type '" "lldb::offset_t""'");
  } 
  arg3 = static_cast< lldb::offset_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (long double)(arg1)->GetLongDouble(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new long double(result)), SWIGTYPE_p_long_double, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::offset_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::addr_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_GetAddress", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetAddress" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_GetAddress" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_GetAddress" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBData_GetAddress" "', argument " "3"" of type '" "lldb::offset_t""'");
  } 
  arg3 = static_cast< lldb::offset_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->GetAddress(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetUnsignedInt8(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::offset_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  uint8_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_GetUnsignedInt8", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetUnsignedInt8" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_GetUnsignedInt8" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_GetUnsignedInt8" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBData_GetUnsignedInt8" "', argument " "3"" of type '" "lldb::offset_t""'");
  } 
  arg3 = static_cast< lldb::offset_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint8_t)(arg1)->GetUnsignedInt8(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetUnsignedInt16(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::offset_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  uint16_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_GetUnsignedInt16", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetUnsignedInt16" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_GetUnsignedInt16" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_GetUnsignedInt16" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBData_GetUnsignedInt16" "', argument " "3"" of type '" "lldb::offset_t""'");
  } 
  arg3 = static_cast< lldb::offset_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint16_t)(arg1)->GetUnsignedInt16(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetUnsignedInt32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::offset_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_GetUnsignedInt32", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetUnsignedInt32" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_GetUnsignedInt32" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_GetUnsignedInt32" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBData_GetUnsignedInt32" "', argument " "3"" of type '" "lldb::offset_t""'");
  } 
  arg3 = static_cast< lldb::offset_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetUnsignedInt32(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetUnsignedInt64(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::offset_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  uint64_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_GetUnsignedInt64", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetUnsignedInt64" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_GetUnsignedInt64" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_GetUnsignedInt64" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBData_GetUnsignedInt64" "', argument " "3"" of type '" "lldb::offset_t""'");
  } 
  arg3 = static_cast< lldb::offset_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetUnsignedInt64(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetSignedInt8(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::offset_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int8_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_GetSignedInt8", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetSignedInt8" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_GetSignedInt8" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_GetSignedInt8" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBData_GetSignedInt8" "', argument " "3"" of type '" "lldb::offset_t""'");
  } 
  arg3 = static_cast< lldb::offset_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int8_t)(arg1)->GetSignedInt8(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetSignedInt16(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::offset_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int16_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_GetSignedInt16", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetSignedInt16" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_GetSignedInt16" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_GetSignedInt16" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBData_GetSignedInt16" "', argument " "3"" of type '" "lldb::offset_t""'");
  } 
  arg3 = static_cast< lldb::offset_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int16_t)(arg1)->GetSignedInt16(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetSignedInt32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::offset_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_GetSignedInt32", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetSignedInt32" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_GetSignedInt32" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_GetSignedInt32" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBData_GetSignedInt32" "', argument " "3"" of type '" "lldb::offset_t""'");
  } 
  arg3 = static_cast< lldb::offset_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int32_t)(arg1)->GetSignedInt32(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetSignedInt64(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::offset_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int64_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_GetSignedInt64", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetSignedInt64" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_GetSignedInt64" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_GetSignedInt64" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBData_GetSignedInt64" "', argument " "3"" of type '" "lldb::offset_t""'");
  } 
  arg3 = static_cast< lldb::offset_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int64_t)(arg1)->GetSignedInt64(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::offset_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_GetString", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetString" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_GetString" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_GetString" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBData_GetString" "', argument " "3"" of type '" "lldb::offset_t""'");
  } 
  arg3 = static_cast< lldb::offset_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetString(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_ReadRawData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::offset_t arg3 ;
  void *arg4 = 0 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[4] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_ReadRawData", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_ReadRawData" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_ReadRawData" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_ReadRawData" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBData_ReadRawData" "', argument " "3"" of type '" "lldb::offset_t""'");
  } 
  arg3 = static_cast< lldb::offset_t >(val3);
  {
    if (PyLong_Check(swig_obj[3])) {
      arg5 = PyLong_AsLong(swig_obj[3]);
    } else {
      PyErr_SetString(PyExc_ValueError, "Expecting an integer or long object");
      SWIG_fail;
    }
    if (arg5 <= 0) {
      PyErr_SetString(PyExc_ValueError, "Positive integer expected");
      SWIG_fail;
    }
    arg4 = (void *)malloc(arg5);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ReadRawData(*arg2,arg3,arg4,SWIG_STD_MOVE(arg5));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  {
    Py_XDECREF(resultobj); /* Blow away any previous result */
    if (result == 0) {
      resultobj = Py_None;
      Py_INCREF(resultobj);
    } else {
      PythonBytes bytes(static_cast<const uint8_t *>(arg4), result);
      resultobj = bytes.release();
    }
    free(arg4);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetDescription__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::addr_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetDescription" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBData_GetDescription" "', argument " "3"" of type '" "lldb::addr_t""'");
  } 
  arg3 = static_cast< lldb::addr_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetDescription__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_GetDescription" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_GetDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBData_GetDescription", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBData_GetDescription__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBData_GetDescription__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBData_GetDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBData::GetDescription(lldb::SBStream &,lldb::addr_t)\n"
    "    lldb::SBData::GetDescription(lldb::SBStream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBData_SetData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  void *arg3 = 0 ;
  size_t arg4 ;
  lldb::ByteOrder arg5 ;
  uint8_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned char val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_SetData", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_SetData" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_SetData" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_SetData" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  {
    if (PythonString::Check(swig_obj[2])) {
      PythonString str(PyRefType::Borrowed, swig_obj[2]);
      arg3 = (void *)str.GetString().data();
      arg4 = str.GetSize();
    } else if (PythonByteArray::Check(swig_obj[2])) {
      PythonByteArray bytearray(PyRefType::Borrowed, swig_obj[2]);
      arg3 = (void *)bytearray.GetBytes().data();
      arg4 = bytearray.GetSize();
    } else if (PythonBytes::Check(swig_obj[2])) {
      PythonBytes bytes(PyRefType::Borrowed, swig_obj[2]);
      arg3 = (void *)bytes.GetBytes().data();
      arg4 = bytes.GetSize();
    } else {
      PyErr_SetString(PyExc_ValueError, "Expecting a buffer");
      SWIG_fail;
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBData_SetData" "', argument " "5"" of type '" "lldb::ByteOrder""'");
  } 
  arg5 = static_cast< lldb::ByteOrder >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_char(swig_obj[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBData_SetData" "', argument " "6"" of type '" "uint8_t""'");
  } 
  arg6 = static_cast< uint8_t >(val6);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetData(*arg2,(void const *)arg3,SWIG_STD_MOVE(arg4),arg5,arg6);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_SetDataWithOwnership(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  void *arg3 = 0 ;
  size_t arg4 ;
  lldb::ByteOrder arg5 ;
  uint8_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned char val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_SetDataWithOwnership", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_SetDataWithOwnership" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_SetDataWithOwnership" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_SetDataWithOwnership" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  {
    if (PythonString::Check(swig_obj[2])) {
      PythonString str(PyRefType::Borrowed, swig_obj[2]);
      arg3 = (void *)str.GetString().data();
      arg4 = str.GetSize();
    } else if (PythonByteArray::Check(swig_obj[2])) {
      PythonByteArray bytearray(PyRefType::Borrowed, swig_obj[2]);
      arg3 = (void *)bytearray.GetBytes().data();
      arg4 = bytearray.GetSize();
    } else if (PythonBytes::Check(swig_obj[2])) {
      PythonBytes bytes(PyRefType::Borrowed, swig_obj[2]);
      arg3 = (void *)bytes.GetBytes().data();
      arg4 = bytes.GetSize();
    } else {
      PyErr_SetString(PyExc_ValueError, "Expecting a buffer");
      SWIG_fail;
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBData_SetDataWithOwnership" "', argument " "5"" of type '" "lldb::ByteOrder""'");
  } 
  arg5 = static_cast< lldb::ByteOrder >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_char(swig_obj[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBData_SetDataWithOwnership" "', argument " "6"" of type '" "uint8_t""'");
  } 
  arg6 = static_cast< uint8_t >(val6);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetDataWithOwnership(*arg2,(void const *)arg3,SWIG_STD_MOVE(arg4),arg5,arg6);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_Append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  lldb::SBData *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_Append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_Append" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBData,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_Append" "', argument " "2"" of type '" "lldb::SBData const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBData_Append" "', argument " "2"" of type '" "lldb::SBData const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBData * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->Append((lldb::SBData const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_CreateDataFromCString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::ByteOrder arg1 ;
  uint32_t arg2 ;
  char *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBData result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_CreateDataFromCString", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBData_CreateDataFromCString" "', argument " "1"" of type '" "lldb::ByteOrder""'");
  } 
  arg1 = static_cast< lldb::ByteOrder >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBData_CreateDataFromCString" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBData_CreateDataFromCString" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBData::CreateDataFromCString(arg1,arg2,(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBData(result)), SWIGTYPE_p_lldb__SBData, SWIG_POINTER_OWN |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_CreateDataFromUInt64Array(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::ByteOrder arg1 ;
  uint32_t arg2 ;
  uint64_t *arg3 = 0 ;
  size_t arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBData result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_CreateDataFromUInt64Array", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBData_CreateDataFromUInt64Array" "', argument " "1"" of type '" "lldb::ByteOrder""'");
  } 
  arg1 = static_cast< lldb::ByteOrder >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBData_CreateDataFromUInt64Array" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    /* Check if is a list  */
    if (PyList_Check(swig_obj[2])) {
      int size = PyList_Size(swig_obj[2]);
      int i = 0;
      arg4 = size;
      arg3 = (uint64_t *)malloc(size * sizeof(uint64_t));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[2], i);
        if (!SetNumberFromPyObject(arg3[i], o)) {
          PyErr_SetString(PyExc_TypeError, "list must contain numbers");
          SWIG_fail;
        }
        
        if (PyErr_Occurred()) {
          SWIG_fail;
        }
      }
    } else if (swig_obj[2] == Py_None) {
      arg3 = NULL;
      arg4 = 0;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBData::CreateDataFromUInt64Array(arg1,arg2,arg3,SWIG_STD_MOVE(arg4));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBData(result)), SWIGTYPE_p_lldb__SBData, SWIG_POINTER_OWN |  0 );
  {
    free(arg3);
  }
  return resultobj;
fail:
  {
    free(arg3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_CreateDataFromUInt32Array(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::ByteOrder arg1 ;
  uint32_t arg2 ;
  uint32_t *arg3 = 0 ;
  size_t arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBData result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_CreateDataFromUInt32Array", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBData_CreateDataFromUInt32Array" "', argument " "1"" of type '" "lldb::ByteOrder""'");
  } 
  arg1 = static_cast< lldb::ByteOrder >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBData_CreateDataFromUInt32Array" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    /* Check if is a list  */
    if (PyList_Check(swig_obj[2])) {
      int size = PyList_Size(swig_obj[2]);
      int i = 0;
      arg4 = size;
      arg3 = (uint32_t *)malloc(size * sizeof(uint32_t));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[2], i);
        if (!SetNumberFromPyObject(arg3[i], o)) {
          PyErr_SetString(PyExc_TypeError, "list must contain numbers");
          SWIG_fail;
        }
        
        if (PyErr_Occurred()) {
          SWIG_fail;
        }
      }
    } else if (swig_obj[2] == Py_None) {
      arg3 = NULL;
      arg4 = 0;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBData::CreateDataFromUInt32Array(arg1,arg2,arg3,SWIG_STD_MOVE(arg4));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBData(result)), SWIGTYPE_p_lldb__SBData, SWIG_POINTER_OWN |  0 );
  {
    free(arg3);
  }
  return resultobj;
fail:
  {
    free(arg3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_CreateDataFromSInt64Array(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::ByteOrder arg1 ;
  uint32_t arg2 ;
  int64_t *arg3 = 0 ;
  size_t arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBData result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_CreateDataFromSInt64Array", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBData_CreateDataFromSInt64Array" "', argument " "1"" of type '" "lldb::ByteOrder""'");
  } 
  arg1 = static_cast< lldb::ByteOrder >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBData_CreateDataFromSInt64Array" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    /* Check if is a list  */
    if (PyList_Check(swig_obj[2])) {
      int size = PyList_Size(swig_obj[2]);
      int i = 0;
      arg4 = size;
      arg3 = (int64_t *)malloc(size * sizeof(int64_t));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[2], i);
        if (!SetNumberFromPyObject(arg3[i], o)) {
          PyErr_SetString(PyExc_TypeError, "list must contain numbers");
          SWIG_fail;
        }
        
        if (PyErr_Occurred()) {
          SWIG_fail;
        }
      }
    } else if (swig_obj[2] == Py_None) {
      arg3 = NULL;
      arg4 = 0;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBData::CreateDataFromSInt64Array(arg1,arg2,arg3,SWIG_STD_MOVE(arg4));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBData(result)), SWIGTYPE_p_lldb__SBData, SWIG_POINTER_OWN |  0 );
  {
    free(arg3);
  }
  return resultobj;
fail:
  {
    free(arg3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_CreateDataFromSInt32Array(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::ByteOrder arg1 ;
  uint32_t arg2 ;
  int32_t *arg3 = 0 ;
  size_t arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBData result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_CreateDataFromSInt32Array", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBData_CreateDataFromSInt32Array" "', argument " "1"" of type '" "lldb::ByteOrder""'");
  } 
  arg1 = static_cast< lldb::ByteOrder >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBData_CreateDataFromSInt32Array" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    /* Check if is a list  */
    if (PyList_Check(swig_obj[2])) {
      int size = PyList_Size(swig_obj[2]);
      int i = 0;
      arg4 = size;
      arg3 = (int32_t *)malloc(size * sizeof(int32_t));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[2], i);
        if (!SetNumberFromPyObject(arg3[i], o)) {
          PyErr_SetString(PyExc_TypeError, "list must contain numbers");
          SWIG_fail;
        }
        
        if (PyErr_Occurred()) {
          SWIG_fail;
        }
      }
    } else if (swig_obj[2] == Py_None) {
      arg3 = NULL;
      arg4 = 0;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBData::CreateDataFromSInt32Array(arg1,arg2,arg3,SWIG_STD_MOVE(arg4));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBData(result)), SWIGTYPE_p_lldb__SBData, SWIG_POINTER_OWN |  0 );
  {
    free(arg3);
  }
  return resultobj;
fail:
  {
    free(arg3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_CreateDataFromDoubleArray(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::ByteOrder arg1 ;
  uint32_t arg2 ;
  double *arg3 = 0 ;
  size_t arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBData result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_CreateDataFromDoubleArray", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBData_CreateDataFromDoubleArray" "', argument " "1"" of type '" "lldb::ByteOrder""'");
  } 
  arg1 = static_cast< lldb::ByteOrder >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBData_CreateDataFromDoubleArray" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    /* Check if is a list  */
    if (PyList_Check(swig_obj[2])) {
      int size = PyList_Size(swig_obj[2]);
      int i = 0;
      arg4 = size;
      arg3 = (double *)malloc(size * sizeof(double));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[2], i);
        if (!SetNumberFromPyObject(arg3[i], o)) {
          PyErr_SetString(PyExc_TypeError, "list must contain numbers");
          SWIG_fail;
        }
        
        if (PyErr_Occurred()) {
          SWIG_fail;
        }
      }
    } else if (swig_obj[2] == Py_None) {
      arg3 = NULL;
      arg4 = 0;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBData::CreateDataFromDoubleArray(arg1,arg2,arg3,SWIG_STD_MOVE(arg4));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBData(result)), SWIGTYPE_p_lldb__SBData, SWIG_POINTER_OWN |  0 );
  {
    free(arg3);
  }
  return resultobj;
fail:
  {
    free(arg3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_SetDataFromCString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_SetDataFromCString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_SetDataFromCString" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBData_SetDataFromCString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetDataFromCString((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_SetDataFromUInt64Array(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  uint64_t *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_SetDataFromUInt64Array", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_SetDataFromUInt64Array" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  {
    /* Check if is a list  */
    if (PyList_Check(swig_obj[1])) {
      int size = PyList_Size(swig_obj[1]);
      int i = 0;
      arg3 = size;
      arg2 = (uint64_t *)malloc(size * sizeof(uint64_t));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[1], i);
        if (!SetNumberFromPyObject(arg2[i], o)) {
          PyErr_SetString(PyExc_TypeError, "list must contain numbers");
          SWIG_fail;
        }
        
        if (PyErr_Occurred()) {
          SWIG_fail;
        }
      }
    } else if (swig_obj[1] == Py_None) {
      arg2 = NULL;
      arg3 = 0;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetDataFromUInt64Array(arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    free(arg2);
  }
  return resultobj;
fail:
  {
    free(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_SetDataFromUInt32Array(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  uint32_t *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_SetDataFromUInt32Array", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_SetDataFromUInt32Array" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  {
    /* Check if is a list  */
    if (PyList_Check(swig_obj[1])) {
      int size = PyList_Size(swig_obj[1]);
      int i = 0;
      arg3 = size;
      arg2 = (uint32_t *)malloc(size * sizeof(uint32_t));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[1], i);
        if (!SetNumberFromPyObject(arg2[i], o)) {
          PyErr_SetString(PyExc_TypeError, "list must contain numbers");
          SWIG_fail;
        }
        
        if (PyErr_Occurred()) {
          SWIG_fail;
        }
      }
    } else if (swig_obj[1] == Py_None) {
      arg2 = NULL;
      arg3 = 0;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetDataFromUInt32Array(arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    free(arg2);
  }
  return resultobj;
fail:
  {
    free(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_SetDataFromSInt64Array(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  int64_t *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_SetDataFromSInt64Array", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_SetDataFromSInt64Array" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  {
    /* Check if is a list  */
    if (PyList_Check(swig_obj[1])) {
      int size = PyList_Size(swig_obj[1]);
      int i = 0;
      arg3 = size;
      arg2 = (int64_t *)malloc(size * sizeof(int64_t));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[1], i);
        if (!SetNumberFromPyObject(arg2[i], o)) {
          PyErr_SetString(PyExc_TypeError, "list must contain numbers");
          SWIG_fail;
        }
        
        if (PyErr_Occurred()) {
          SWIG_fail;
        }
      }
    } else if (swig_obj[1] == Py_None) {
      arg2 = NULL;
      arg3 = 0;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetDataFromSInt64Array(arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    free(arg2);
  }
  return resultobj;
fail:
  {
    free(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_SetDataFromSInt32Array(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  int32_t *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_SetDataFromSInt32Array", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_SetDataFromSInt32Array" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  {
    /* Check if is a list  */
    if (PyList_Check(swig_obj[1])) {
      int size = PyList_Size(swig_obj[1]);
      int i = 0;
      arg3 = size;
      arg2 = (int32_t *)malloc(size * sizeof(int32_t));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[1], i);
        if (!SetNumberFromPyObject(arg2[i], o)) {
          PyErr_SetString(PyExc_TypeError, "list must contain numbers");
          SWIG_fail;
        }
        
        if (PyErr_Occurred()) {
          SWIG_fail;
        }
      }
    } else if (swig_obj[1] == Py_None) {
      arg2 = NULL;
      arg3 = 0;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetDataFromSInt32Array(arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    free(arg2);
  }
  return resultobj;
fail:
  {
    free(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData_SetDataFromDoubleArray(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  double *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBData_SetDataFromDoubleArray", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData_SetDataFromDoubleArray" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  {
    /* Check if is a list  */
    if (PyList_Check(swig_obj[1])) {
      int size = PyList_Size(swig_obj[1]);
      int i = 0;
      arg3 = size;
      arg2 = (double *)malloc(size * sizeof(double));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[1], i);
        if (!SetNumberFromPyObject(arg2[i], o)) {
          PyErr_SetString(PyExc_TypeError, "list must contain numbers");
          SWIG_fail;
        }
        
        if (PyErr_Occurred()) {
          SWIG_fail;
        }
      }
    } else if (swig_obj[1] == Py_None) {
      arg2 = NULL;
      arg3 = 0;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetDataFromDoubleArray(arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    free(arg2);
  }
  return resultobj;
fail:
  {
    free(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBData___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBData___repr__" "', argument " "1"" of type '" "lldb::SBData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBData___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBDebugger__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBDebugger *)new lldb::SBDebugger();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBDebugger__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBDebugger *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBDebugger,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBDebugger" "', argument " "1"" of type '" "lldb::SBDebugger const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBDebugger" "', argument " "1"" of type '" "lldb::SBDebugger const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBDebugger *)new lldb::SBDebugger((lldb::SBDebugger const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBDebugger(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBDebugger", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBDebugger__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBDebugger__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBDebugger'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBDebugger::SBDebugger()\n"
    "    lldb::SBDebugger::SBDebugger(lldb::SBDebugger const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBDebugger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBDebugger" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetBroadcasterClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetBroadcasterClass", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBDebugger::GetBroadcasterClass();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SupportsLanguage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::LanguageType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBDebugger_SupportsLanguage" "', argument " "1"" of type '" "lldb::LanguageType""'");
  } 
  arg1 = static_cast< lldb::LanguageType >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBDebugger::SupportsLanguage(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetBroadcaster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBroadcaster result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetBroadcaster" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetBroadcaster();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBroadcaster(result)), SWIGTYPE_p_lldb__SBBroadcaster, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetProgressFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  uint64_t *arg2 = 0 ;
  uint64_t *arg3 = 0 ;
  uint64_t *arg4 = 0 ;
  bool *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint64_t temp2 ;
  int res2 = SWIG_TMPOBJ ;
  uint64_t temp3 ;
  int res3 = SWIG_TMPOBJ ;
  uint64_t temp4 ;
  int res4 = SWIG_TMPOBJ ;
  bool temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetProgressFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_GetProgressFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBDebugger::GetProgressFromEvent((lldb::SBEvent const &)*arg1,*arg2,*arg3,*arg4,*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_long_SS_long((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_long_long, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_long_SS_long((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_long_long, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_long_SS_long((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_long_long, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_bool((*arg5)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_bool, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetProgressDataFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetProgressDataFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_GetProgressDataFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBDebugger::GetProgressDataFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetDiagnosticFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetDiagnosticFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_GetDiagnosticFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBDebugger::GetDiagnosticFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_Initialize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_Initialize", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb::SBDebugger::Initialize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_InitializeWithErrorHandling(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_InitializeWithErrorHandling", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBDebugger::InitializeWithErrorHandling();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_PrintStackTraceOnError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_PrintStackTraceOnError", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb::SBDebugger::PrintStackTraceOnError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_PrintDiagnosticsOnError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_PrintDiagnosticsOnError", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb::SBDebugger::PrintDiagnosticsOnError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_Terminate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_Terminate", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb::SBDebugger::Terminate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_Create__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBDebugger result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBDebugger::Create();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBDebugger(result)), SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_Create__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  lldb::SBDebugger result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBDebugger_Create" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBDebugger::Create(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBDebugger(result)), SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_Create__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  lldb::LogOutputCallback arg2 = 0 ;
  void *arg3 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  lldb::SBDebugger result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBDebugger_Create" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    if (!(swig_obj[1] == Py_None ||
        PyCallable_Check(reinterpret_cast<PyObject *>(swig_obj[1])))) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object or None!");
      SWIG_fail;
    }
    
    // FIXME (filcab): We can't currently check if our callback is already
    // LLDBSwigPythonCallPythonLogOutputCallback (to DECREF the previous
    // baton) nor can we just remove all traces of a callback, if we want to
    // revert to a file logging mechanism.
    
    // Don't lose the callback reference
    Py_INCREF(swig_obj[1]);
    arg2 = LLDBSwigPythonCallPythonLogOutputCallback;
    arg3 = swig_obj[1];
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBDebugger::Create(arg1,arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBDebugger(result)), SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_Create(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBDebugger_Create", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_SBDebugger_Create__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_SBDebugger_Create__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = argv[1] == Py_None;
        _v = _v || PyCallable_Check(reinterpret_cast<PyObject *>(argv[1]));
      }
      if (_v) {
        if (argc <= 2) {
          return _wrap_SBDebugger_Create__SWIG_2(self, argc, argv);
        }
        return _wrap_SBDebugger_Create__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBDebugger_Create'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBDebugger::Create()\n"
    "    lldb::SBDebugger::Create(bool)\n"
    "    lldb::SBDebugger::Create(bool,lldb::LogOutputCallback,void *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBDebugger_Destroy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBDebugger,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_Destroy" "', argument " "1"" of type '" "lldb::SBDebugger &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_Destroy" "', argument " "1"" of type '" "lldb::SBDebugger &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb::SBDebugger::Destroy(*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_MemoryPressureDetected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_MemoryPressureDetected", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb::SBDebugger::MemoryPressureDetected();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger___nonzero__" "', argument " "1"" of type '" "lldb::SBDebugger const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBDebugger const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_IsValid" "', argument " "1"" of type '" "lldb::SBDebugger const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBDebugger const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_Clear" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetSetting__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBStructuredData result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetSetting" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_GetSetting" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSetting((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetSetting__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBStructuredData result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetSetting" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSetting();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetSetting(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBDebugger_GetSetting", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBDebugger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBDebugger_GetSetting__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBDebugger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBDebugger_GetSetting__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBDebugger_GetSetting'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBDebugger::GetSetting(char const *)\n"
    "    lldb::SBDebugger::GetSetting()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetAsync(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetAsync", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetAsync" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_SetAsync" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAsync(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetAsync(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetAsync" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetAsync();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SkipLLDBInitFiles(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SkipLLDBInitFiles", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SkipLLDBInitFiles" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_SkipLLDBInitFiles" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SkipLLDBInitFiles(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SkipAppInitFiles(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SkipAppInitFiles", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SkipAppInitFiles" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_SkipAppInitFiles" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SkipAppInitFiles(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetInputString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetInputString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetInputString" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_SetInputString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetInputString((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetInputFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBFile arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetInputFile" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFile,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_SetInputFile" "', argument " "2"" of type '" "lldb::SBFile""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_SetInputFile" "', argument " "2"" of type '" "lldb::SBFile""'");
    } else {
      lldb::SBFile * temp = reinterpret_cast< lldb::SBFile * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetInputFile(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetOutputFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBFile arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetOutputFile" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFile,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_SetOutputFile" "', argument " "2"" of type '" "lldb::SBFile""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_SetOutputFile" "', argument " "2"" of type '" "lldb::SBFile""'");
    } else {
      lldb::SBFile * temp = reinterpret_cast< lldb::SBFile * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetOutputFile(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetErrorFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBFile arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetErrorFile" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFile,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_SetErrorFile" "', argument " "2"" of type '" "lldb::SBFile""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_SetErrorFile" "', argument " "2"" of type '" "lldb::SBFile""'");
    } else {
      lldb::SBFile * temp = reinterpret_cast< lldb::SBFile * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetErrorFile(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetInputFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetInputFile" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[1]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp = unwrapOrSetPythonException(py_file.ConvertToFile());
    if (!sp)
    SWIG_fail;
    arg2 = sp;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetInputFile(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetInputFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBDebugger_SetInputFile", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBDebugger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBDebugger_SetInputFile__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBDebugger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        if (PythonFile::Check(argv[1])) {
          _v = 1;
        } else {
          PyErr_Clear();
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SBDebugger_SetInputFile__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBDebugger_SetInputFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBDebugger::SetInputFile(lldb::SBFile)\n"
    "    lldb::SBDebugger::SetInputFile(lldb::FileSP)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetOutputFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetOutputFile" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[1]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp = unwrapOrSetPythonException(py_file.ConvertToFile());
    if (!sp)
    SWIG_fail;
    arg2 = sp;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetOutputFile(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetOutputFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBDebugger_SetOutputFile", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBDebugger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBDebugger_SetOutputFile__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBDebugger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        if (PythonFile::Check(argv[1])) {
          _v = 1;
        } else {
          PyErr_Clear();
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SBDebugger_SetOutputFile__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBDebugger_SetOutputFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBDebugger::SetOutputFile(lldb::SBFile)\n"
    "    lldb::SBDebugger::SetOutputFile(lldb::FileSP)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetErrorFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetErrorFile" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[1]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp = unwrapOrSetPythonException(py_file.ConvertToFile());
    if (!sp)
    SWIG_fail;
    arg2 = sp;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetErrorFile(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetErrorFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBDebugger_SetErrorFile", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBDebugger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBDebugger_SetErrorFile__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBDebugger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        if (PythonFile::Check(argv[1])) {
          _v = 1;
        } else {
          PyErr_Clear();
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SBDebugger_SetErrorFile__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBDebugger_SetErrorFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBDebugger::SetErrorFile(lldb::SBFile)\n"
    "    lldb::SBDebugger::SetErrorFile(lldb::FileSP)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetInputFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFile result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetInputFile" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetInputFile();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFile(result)), SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetOutputFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFile result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetOutputFile" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetOutputFile();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFile(result)), SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetErrorFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFile result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetErrorFile" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetErrorFile();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFile(result)), SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SaveInputTerminalState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SaveInputTerminalState" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SaveInputTerminalState();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_RestoreInputTerminalState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_RestoreInputTerminalState" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->RestoreInputTerminalState();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetCommandInterpreter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBCommandInterpreter result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetCommandInterpreter" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetCommandInterpreter();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBCommandInterpreter(result)), SWIGTYPE_p_lldb__SBCommandInterpreter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_HandleCommand(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_HandleCommand", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_HandleCommand" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_HandleCommand" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->HandleCommand((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_RequestInterrupt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_RequestInterrupt" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->RequestInterrupt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_CancelInterruptRequest(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_CancelInterruptRequest" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->CancelInterruptRequest();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_InterruptRequested(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_InterruptRequested" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->InterruptRequested();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBListener result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetListener" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetListener();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBListener(result)), SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_HandleProcessEvent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBProcess *arg2 = 0 ;
  lldb::SBEvent *arg3 = 0 ;
  lldb::SBFile arg4 ;
  lldb::SBFile arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_HandleProcessEvent" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBProcess,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_HandleProcessEvent" "', argument " "2"" of type '" "lldb::SBProcess const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_HandleProcessEvent" "', argument " "2"" of type '" "lldb::SBProcess const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBProcess * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBDebugger_HandleProcessEvent" "', argument " "3"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_HandleProcessEvent" "', argument " "3"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBEvent * >(argp3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBFile,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBDebugger_HandleProcessEvent" "', argument " "4"" of type '" "lldb::SBFile""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_HandleProcessEvent" "', argument " "4"" of type '" "lldb::SBFile""'");
    } else {
      lldb::SBFile * temp = reinterpret_cast< lldb::SBFile * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBFile,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBDebugger_HandleProcessEvent" "', argument " "5"" of type '" "lldb::SBFile""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_HandleProcessEvent" "', argument " "5"" of type '" "lldb::SBFile""'");
    } else {
      lldb::SBFile * temp = reinterpret_cast< lldb::SBFile * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->HandleProcessEvent((lldb::SBProcess const &)*arg2,(lldb::SBEvent const &)*arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_HandleProcessEvent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBProcess *arg2 = 0 ;
  lldb::SBEvent *arg3 = 0 ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg4 ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_HandleProcessEvent" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBProcess,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_HandleProcessEvent" "', argument " "2"" of type '" "lldb::SBProcess const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_HandleProcessEvent" "', argument " "2"" of type '" "lldb::SBProcess const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBProcess * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBDebugger_HandleProcessEvent" "', argument " "3"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_HandleProcessEvent" "', argument " "3"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBEvent * >(argp3);
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[3]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp =
    unwrapOrSetPythonException(py_file.ConvertToFile(/*borrowed=*/true));
    if (!sp)
    SWIG_fail;
    arg4 = sp;
  }
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[4]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp =
    unwrapOrSetPythonException(py_file.ConvertToFile(/*borrowed=*/true));
    if (!sp)
    SWIG_fail;
    arg5 = sp;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->HandleProcessEvent((lldb::SBProcess const &)*arg2,(lldb::SBEvent const &)*arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_HandleProcessEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBDebugger_HandleProcessEvent", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBDebugger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SBDebugger_HandleProcessEvent__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBDebugger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            if (PythonFile::Check(argv[3])) {
              _v = 1;
            } else {
              PyErr_Clear();
              _v = 0;
            }
          }
          if (_v) {
            {
              if (PythonFile::Check(argv[4])) {
                _v = 1;
              } else {
                PyErr_Clear();
                _v = 0;
              }
            }
            if (_v) {
              return _wrap_SBDebugger_HandleProcessEvent__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBDebugger_HandleProcessEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBDebugger::HandleProcessEvent(lldb::SBProcess const &,lldb::SBEvent const &,lldb::SBFile,lldb::SBFile)\n"
    "    lldb::SBDebugger::HandleProcessEvent(lldb::SBProcess const &,lldb::SBEvent const &,lldb::FileSP,lldb::FileSP)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBDebugger_CreateTarget__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  bool arg5 ;
  lldb::SBError *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  lldb::SBTarget result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_CreateTarget" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_CreateTarget" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBDebugger_CreateTarget" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBDebugger_CreateTarget" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBDebugger_CreateTarget" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SBDebugger_CreateTarget" "', argument " "6"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_CreateTarget" "', argument " "6"" of type '" "lldb::SBError &""'"); 
  }
  arg6 = reinterpret_cast< lldb::SBError * >(argp6);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateTarget((char const *)arg2,(char const *)arg3,(char const *)arg4,arg5,*arg6);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_CreateTargetWithFileAndTargetTriple(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBTarget result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_CreateTargetWithFileAndTargetTriple", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_CreateTargetWithFileAndTargetTriple" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_CreateTargetWithFileAndTargetTriple" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBDebugger_CreateTargetWithFileAndTargetTriple" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateTargetWithFileAndTargetTriple((char const *)arg2,(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_CreateTargetWithFileAndArch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBTarget result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_CreateTargetWithFileAndArch", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_CreateTargetWithFileAndArch" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_CreateTargetWithFileAndArch" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBDebugger_CreateTargetWithFileAndArch" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateTargetWithFileAndArch((char const *)arg2,(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_CreateTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBTarget result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_CreateTarget" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_CreateTarget" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateTarget((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_CreateTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBDebugger_CreateTarget", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBDebugger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBDebugger_CreateTarget__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBDebugger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_SBDebugger_CreateTarget__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBDebugger_CreateTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBDebugger::CreateTarget(char const *,char const *,char const *,bool,lldb::SBError &)\n"
    "    lldb::SBDebugger::CreateTarget(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetDummyTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTarget result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetDummyTarget" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetDummyTarget();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_DeleteTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBTarget *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_DeleteTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_DeleteTarget" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_DeleteTarget" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_DeleteTarget" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->DeleteTarget(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetTargetAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTarget result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetTargetAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetTargetAtIndex" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_GetTargetAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTargetAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetIndexOfTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBTarget arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetIndexOfTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetIndexOfTarget" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_GetIndexOfTarget" "', argument " "2"" of type '" "lldb::SBTarget""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_GetIndexOfTarget" "', argument " "2"" of type '" "lldb::SBTarget""'");
    } else {
      lldb::SBTarget * temp = reinterpret_cast< lldb::SBTarget * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetIndexOfTarget(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_FindTargetWithProcessID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::pid_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTarget result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_FindTargetWithProcessID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_FindTargetWithProcessID" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_FindTargetWithProcessID" "', argument " "2"" of type '" "lldb::pid_t""'");
  } 
  arg2 = static_cast< lldb::pid_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindTargetWithProcessID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_FindTargetWithFileAndArch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBTarget result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_FindTargetWithFileAndArch", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_FindTargetWithFileAndArch" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_FindTargetWithFileAndArch" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBDebugger_FindTargetWithFileAndArch" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindTargetWithFileAndArch((char const *)arg2,(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_FindTargetByGloballyUniqueID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::user_id_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTarget result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_FindTargetByGloballyUniqueID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_FindTargetByGloballyUniqueID" "', argument " "1"" of type '" "lldb::SBDebugger const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_FindTargetByGloballyUniqueID" "', argument " "2"" of type '" "lldb::user_id_t""'");
  } 
  arg2 = static_cast< lldb::user_id_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBDebugger const *)arg1)->FindTargetByGloballyUniqueID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetNumTargets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetNumTargets" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumTargets();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetSelectedTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTarget result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetSelectedTarget" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSelectedTarget();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetSelectedTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBTarget *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetSelectedTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetSelectedTarget" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_SetSelectedTarget" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_SetSelectedTarget" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetSelectedTarget(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetSelectedPlatform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBPlatform result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetSelectedPlatform" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSelectedPlatform();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBPlatform(result)), SWIGTYPE_p_lldb__SBPlatform, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetSelectedPlatform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBPlatform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetSelectedPlatform", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetSelectedPlatform" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBPlatform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_SetSelectedPlatform" "', argument " "2"" of type '" "lldb::SBPlatform &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_SetSelectedPlatform" "', argument " "2"" of type '" "lldb::SBPlatform &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBPlatform * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetSelectedPlatform(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetNumPlatforms(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetNumPlatforms" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumPlatforms();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetPlatformAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBPlatform result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetPlatformAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetPlatformAtIndex" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_GetPlatformAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetPlatformAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBPlatform(result)), SWIGTYPE_p_lldb__SBPlatform, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetNumAvailablePlatforms(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetNumAvailablePlatforms" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumAvailablePlatforms();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetAvailablePlatformInfoAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetAvailablePlatformInfoAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetAvailablePlatformInfoAtIndex" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_GetAvailablePlatformInfoAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetAvailablePlatformInfoAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetSourceManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< lldb::SBSourceManager > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetSourceManager" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSourceManager();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSourceManager(result)), SWIGTYPE_p_lldb__SBSourceManager, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetCurrentPlatform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetCurrentPlatform", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetCurrentPlatform" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_SetCurrentPlatform" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetCurrentPlatform((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetCurrentPlatformSDKRoot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetCurrentPlatformSDKRoot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetCurrentPlatformSDKRoot" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_SetCurrentPlatformSDKRoot" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetCurrentPlatformSDKRoot((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetUseExternalEditor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetUseExternalEditor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetUseExternalEditor" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_SetUseExternalEditor" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetUseExternalEditor(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetUseExternalEditor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetUseExternalEditor" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetUseExternalEditor();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetUseColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetUseColor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetUseColor" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_SetUseColor" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetUseColor(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetUseColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetUseColor" "', argument " "1"" of type '" "lldb::SBDebugger const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBDebugger const *)arg1)->GetUseColor();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetShowInlineDiagnostics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetShowInlineDiagnostics", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetShowInlineDiagnostics" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_SetShowInlineDiagnostics" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetShowInlineDiagnostics(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetUseSourceCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetUseSourceCache", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetUseSourceCache" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_SetUseSourceCache" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetUseSourceCache(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetUseSourceCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetUseSourceCache" "', argument " "1"" of type '" "lldb::SBDebugger const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBDebugger const *)arg1)->GetUseSourceCache();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetDefaultArchitecture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  size_t arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetDefaultArchitecture", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetDefaultArchitecture" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_GetDefaultArchitecture" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBDebugger::GetDefaultArchitecture(arg1,SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetDefaultArchitecture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetDefaultArchitecture" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBDebugger::SetDefaultArchitecture((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetScriptingLanguage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::ScriptLanguage result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetScriptingLanguage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetScriptingLanguage" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_GetScriptingLanguage" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ScriptLanguage)(arg1)->GetScriptingLanguage((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetScriptInterpreterInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::ScriptLanguage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetScriptInterpreterInfo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetScriptInterpreterInfo" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_GetScriptInterpreterInfo" "', argument " "2"" of type '" "lldb::ScriptLanguage""'");
  } 
  arg2 = static_cast< lldb::ScriptLanguage >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetScriptInterpreterInfo(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetVersionString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetVersionString", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBDebugger::GetVersionString();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_StateAsCString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::StateType arg1 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    PythonObject obj = Retain<PythonObject>(swig_obj[0]);
    unsigned long long state_type_value =
    unwrapOrSetPythonException(As<unsigned long long>(obj));
    if (PyErr_Occurred())
    SWIG_fail;
    if (state_type_value > lldb::StateType::kLastStateType) {
      PyErr_SetString(PyExc_ValueError, "Not a valid StateType value");
      SWIG_fail;
    }
    arg1 = static_cast<lldb::StateType>(state_type_value);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBDebugger::StateAsCString(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetBuildConfiguration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetBuildConfiguration", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBDebugger::GetBuildConfiguration();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_StateIsRunningState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::StateType arg1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    PythonObject obj = Retain<PythonObject>(swig_obj[0]);
    unsigned long long state_type_value =
    unwrapOrSetPythonException(As<unsigned long long>(obj));
    if (PyErr_Occurred())
    SWIG_fail;
    if (state_type_value > lldb::StateType::kLastStateType) {
      PyErr_SetString(PyExc_ValueError, "Not a valid StateType value");
      SWIG_fail;
    }
    arg1 = static_cast<lldb::StateType>(state_type_value);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBDebugger::StateIsRunningState(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_StateIsStoppedState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::StateType arg1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    PythonObject obj = Retain<PythonObject>(swig_obj[0]);
    unsigned long long state_type_value =
    unwrapOrSetPythonException(As<unsigned long long>(obj));
    if (PyErr_Occurred())
    SWIG_fail;
    if (state_type_value > lldb::StateType::kLastStateType) {
      PyErr_SetString(PyExc_ValueError, "Not a valid StateType value");
      SWIG_fail;
    }
    arg1 = static_cast<lldb::StateType>(state_type_value);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBDebugger::StateIsStoppedState(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_EnableLog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  char *arg2 = 0 ;
  char **arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_EnableLog", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_EnableLog" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_EnableLog" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    /* Check if is a list  */
    if (PythonList::Check(swig_obj[2])) {
      PythonList list(PyRefType::Borrowed, swig_obj[2]);
      int size = list.GetSize();
      int i = 0;
      arg3 = (char **)malloc((size + 1) * sizeof(char *));
      for (i = 0; i < size; i++) {
        PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
        if (!py_str.IsAllocated()) {
          PyErr_SetString(PyExc_TypeError, "list must contain strings");
          SWIG_fail;
        }
        
        arg3[i] = const_cast<char *>(py_str.GetString().data());
      }
      arg3[i] = 0;
    } else if (swig_obj[2] == Py_None) {
      arg3 = NULL;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->EnableLog((char const *)arg2,(char const **)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  {
    free((char *) arg3);
  }
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  {
    free((char *) arg3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetLoggingCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::LogOutputCallback arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetLoggingCallback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetLoggingCallback" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    if (!(swig_obj[1] == Py_None ||
        PyCallable_Check(reinterpret_cast<PyObject *>(swig_obj[1])))) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object or None!");
      SWIG_fail;
    }
    
    // FIXME (filcab): We can't currently check if our callback is already
    // LLDBSwigPythonCallPythonLogOutputCallback (to DECREF the previous
    // baton) nor can we just remove all traces of a callback, if we want to
    // revert to a file logging mechanism.
    
    // Don't lose the callback reference
    Py_INCREF(swig_obj[1]);
    arg2 = LLDBSwigPythonCallPythonLogOutputCallback;
    arg3 = swig_obj[1];
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetLoggingCallback(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetDestroyCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBDebuggerDestroyCallback arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetDestroyCallback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetDestroyCallback" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    if (!(swig_obj[1] == Py_None ||
        PyCallable_Check(reinterpret_cast<PyObject *>(swig_obj[1])))) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object or None!");
      SWIG_fail;
    }
    
    // FIXME (filcab): We can't currently check if our callback is already
    // LLDBSwigPythonCallPythonSBDebuggerTerminateCallback (to DECREF the previous
    // baton) nor can we just remove all traces of a callback, if we want to
    // revert to a file logging mechanism.
    
    // Don't lose the callback reference
    Py_INCREF(swig_obj[1]);
    arg2 = LLDBSwigPythonCallPythonSBDebuggerTerminateCallback;
    arg3 = swig_obj[1];
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetDestroyCallback(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_AddDestroyCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBDebuggerDestroyCallback arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::callback_token_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_AddDestroyCallback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_AddDestroyCallback" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    if (!(swig_obj[1] == Py_None ||
        PyCallable_Check(reinterpret_cast<PyObject *>(swig_obj[1])))) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object or None!");
      SWIG_fail;
    }
    
    // FIXME (filcab): We can't currently check if our callback is already
    // LLDBSwigPythonCallPythonSBDebuggerTerminateCallback (to DECREF the previous
    // baton) nor can we just remove all traces of a callback, if we want to
    // revert to a file logging mechanism.
    
    // Don't lose the callback reference
    Py_INCREF(swig_obj[1]);
    arg2 = LLDBSwigPythonCallPythonSBDebuggerTerminateCallback;
    arg3 = swig_obj[1];
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::callback_token_t)(arg1)->AddDestroyCallback(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_RemoveDestroyCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::callback_token_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_RemoveDestroyCallback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_RemoveDestroyCallback" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_RemoveDestroyCallback" "', argument " "2"" of type '" "lldb::callback_token_t""'");
  } 
  arg2 = static_cast< lldb::callback_token_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->RemoveDestroyCallback(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_DispatchInput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_DispatchInput", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_DispatchInput" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    if (PythonString::Check(swig_obj[1])) {
      PythonString str(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (void *)str.GetString().data();
      arg3 = str.GetSize();
    } else if (PythonByteArray::Check(swig_obj[1])) {
      PythonByteArray bytearray(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (void *)bytearray.GetBytes().data();
      arg3 = bytearray.GetSize();
    } else if (PythonBytes::Check(swig_obj[1])) {
      PythonBytes bytes(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (void *)bytes.GetBytes().data();
      arg3 = bytes.GetSize();
    } else {
      PyErr_SetString(PyExc_ValueError, "Expecting a buffer");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->DispatchInput((void const *)arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_DispatchInputInterrupt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_DispatchInputInterrupt" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->DispatchInputInterrupt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_DispatchInputEndOfFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_DispatchInputEndOfFile" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->DispatchInputEndOfFile();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetInstanceName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetInstanceName" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetInstanceName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_FindDebuggerWithID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBDebugger result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBDebugger_FindDebuggerWithID" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBDebugger::FindDebuggerWithID(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBDebugger(result)), SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetInternalVariable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetInternalVariable", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetInternalVariable" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_SetInternalVariable" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBDebugger_SetInternalVariable" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBDebugger::SetInternalVariable((char const *)arg1,(char const *)arg2,(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetInternalVariableValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBStringList result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetInternalVariableValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetInternalVariableValue" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_GetInternalVariableValue" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBDebugger::GetInternalVariableValue((char const *)arg1,(char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStringList(result)), SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetDescription" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetTerminalWidth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetTerminalWidth" "', argument " "1"" of type '" "lldb::SBDebugger const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBDebugger const *)arg1)->GetTerminalWidth();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetTerminalWidth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetTerminalWidth", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetTerminalWidth" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_SetTerminalWidth" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetTerminalWidth(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetTerminalHeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetTerminalHeight" "', argument " "1"" of type '" "lldb::SBDebugger const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBDebugger const *)arg1)->GetTerminalHeight();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetTerminalHeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetTerminalHeight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetTerminalHeight" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_SetTerminalHeight" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetTerminalHeight(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::user_id_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetID" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::user_id_t)(arg1)->GetID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetPrompt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetPrompt" "', argument " "1"" of type '" "lldb::SBDebugger const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBDebugger const *)arg1)->GetPrompt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetPrompt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetPrompt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetPrompt" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_SetPrompt" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetPrompt((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetReproducerPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetReproducerPath" "', argument " "1"" of type '" "lldb::SBDebugger const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBDebugger const *)arg1)->GetReproducerPath();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetScriptLanguage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::ScriptLanguage result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetScriptLanguage" "', argument " "1"" of type '" "lldb::SBDebugger const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ScriptLanguage)((lldb::SBDebugger const *)arg1)->GetScriptLanguage();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetScriptLanguage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::ScriptLanguage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetScriptLanguage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetScriptLanguage" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_SetScriptLanguage" "', argument " "2"" of type '" "lldb::ScriptLanguage""'");
  } 
  arg2 = static_cast< lldb::ScriptLanguage >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetScriptLanguage(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetREPLLanguage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::LanguageType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetREPLLanguage" "', argument " "1"" of type '" "lldb::SBDebugger const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::LanguageType)((lldb::SBDebugger const *)arg1)->GetREPLLanguage();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetREPLLanguage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::LanguageType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetREPLLanguage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetREPLLanguage" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_SetREPLLanguage" "', argument " "2"" of type '" "lldb::LanguageType""'");
  } 
  arg2 = static_cast< lldb::LanguageType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetREPLLanguage(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetCloseInputOnEOF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetCloseInputOnEOF" "', argument " "1"" of type '" "lldb::SBDebugger const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBDebugger const *)arg1)->GetCloseInputOnEOF();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_SetCloseInputOnEOF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_SetCloseInputOnEOF", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_SetCloseInputOnEOF" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_SetCloseInputOnEOF" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetCloseInputOnEOF(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetCategory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBTypeCategory result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetCategory" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_GetCategory" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetCategory((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeCategory(result)), SWIGTYPE_p_lldb__SBTypeCategory, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetCategory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::LanguageType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  lldb::SBTypeCategory result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetCategory" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_GetCategory" "', argument " "2"" of type '" "lldb::LanguageType""'");
  } 
  arg2 = static_cast< lldb::LanguageType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetCategory(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeCategory(result)), SWIGTYPE_p_lldb__SBTypeCategory, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetCategory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBDebugger_GetCategory", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBDebugger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBDebugger_GetCategory__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBDebugger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBDebugger_GetCategory__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBDebugger_GetCategory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBDebugger::GetCategory(char const *)\n"
    "    lldb::SBDebugger::GetCategory(lldb::LanguageType)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBDebugger_CreateCategory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeCategory result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_CreateCategory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_CreateCategory" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_CreateCategory" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateCategory((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeCategory(result)), SWIGTYPE_p_lldb__SBTypeCategory, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_DeleteCategory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_DeleteCategory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_DeleteCategory" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_DeleteCategory" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->DeleteCategory((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetNumCategories(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetNumCategories" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumCategories();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetCategoryAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeCategory result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetCategoryAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetCategoryAtIndex" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_GetCategoryAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetCategoryAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeCategory(result)), SWIGTYPE_p_lldb__SBTypeCategory, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetDefaultCategory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTypeCategory result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetDefaultCategory" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetDefaultCategory();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeCategory(result)), SWIGTYPE_p_lldb__SBTypeCategory, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetFormatForType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBTypeNameSpecifier arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeFormat result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetFormatForType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetFormatForType" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_GetFormatForType" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_GetFormatForType" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'");
    } else {
      lldb::SBTypeNameSpecifier * temp = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetFormatForType(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeFormat(result)), SWIGTYPE_p_lldb__SBTypeFormat, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetSummaryForType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBTypeNameSpecifier arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeSummary result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetSummaryForType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetSummaryForType" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_GetSummaryForType" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_GetSummaryForType" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'");
    } else {
      lldb::SBTypeNameSpecifier * temp = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSummaryForType(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSummary(result)), SWIGTYPE_p_lldb__SBTypeSummary, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetFilterForType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBTypeNameSpecifier arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeFilter result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetFilterForType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetFilterForType" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_GetFilterForType" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_GetFilterForType" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'");
    } else {
      lldb::SBTypeNameSpecifier * temp = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetFilterForType(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeFilter(result)), SWIGTYPE_p_lldb__SBTypeFilter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetSyntheticForType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBTypeNameSpecifier arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeSynthetic result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_GetSyntheticForType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetSyntheticForType" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_GetSyntheticForType" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_GetSyntheticForType" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'");
    } else {
      lldb::SBTypeNameSpecifier * temp = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSyntheticForType(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSynthetic(result)), SWIGTYPE_p_lldb__SBTypeSynthetic, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_ResetStatistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_ResetStatistics" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->ResetStatistics();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_RunCommandInterpreter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  lldb::SBCommandInterpreterRunOptions *arg4 = 0 ;
  int *arg5 = 0 ;
  bool *arg6 = 0 ;
  bool *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int temp5 ;
  int res5 = 0 ;
  bool temp6 ;
  int res6 = 0 ;
  bool temp7 ;
  int res7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_RunCommandInterpreter", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_RunCommandInterpreter" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_RunCommandInterpreter" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBDebugger_RunCommandInterpreter" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBDebugger_RunCommandInterpreter" "', argument " "4"" of type '" "lldb::SBCommandInterpreterRunOptions &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_RunCommandInterpreter" "', argument " "4"" of type '" "lldb::SBCommandInterpreterRunOptions &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBCommandInterpreterRunOptions * >(argp4);
  if (!(SWIG_IsOK((res5 = SWIG_ConvertPtr(swig_obj[4],SWIG_as_voidptrptr(&arg5),SWIGTYPE_p_int,0))))) {
    int val;
    int ecode = SWIG_AsVal_int(swig_obj[4], &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "SBDebugger_RunCommandInterpreter" "', argument " "5"" of type '" "int""'");
    }
    temp5 = static_cast< int >(val);
    arg5 = &temp5;
    res5 = SWIG_AddTmpMask(ecode);
  }
  if (!(SWIG_IsOK((res6 = SWIG_ConvertPtr(swig_obj[5],SWIG_as_voidptrptr(&arg6),SWIGTYPE_p_bool,0))))) {
    bool val;
    int ecode = SWIG_AsVal_bool(swig_obj[5], &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "SBDebugger_RunCommandInterpreter" "', argument " "6"" of type '" "bool""'");
    }
    temp6 = static_cast< bool >(val);
    arg6 = &temp6;
    res6 = SWIG_AddTmpMask(ecode);
  }
  if (!(SWIG_IsOK((res7 = SWIG_ConvertPtr(swig_obj[6],SWIG_as_voidptrptr(&arg7),SWIGTYPE_p_bool,0))))) {
    bool val;
    int ecode = SWIG_AsVal_bool(swig_obj[6], &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "SBDebugger_RunCommandInterpreter" "', argument " "7"" of type '" "bool""'");
    }
    temp7 = static_cast< bool >(val);
    arg7 = &temp7;
    res7 = SWIG_AddTmpMask(ecode);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->RunCommandInterpreter(arg2,arg3,*arg4,*arg5,*arg6,*arg7);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_bool((*arg6)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_bool, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_bool((*arg7)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_bool, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_RunREPL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::LanguageType arg2 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_RunREPL", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_RunREPL" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDebugger_RunREPL" "', argument " "2"" of type '" "lldb::LanguageType""'");
  } 
  arg2 = static_cast< lldb::LanguageType >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBDebugger_RunREPL" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->RunREPL(arg2,(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_LoadTraceFromFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::SBFileSpec *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBTrace result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDebugger_LoadTraceFromFile", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_LoadTraceFromFile" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDebugger_LoadTraceFromFile" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_LoadTraceFromFile" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBDebugger_LoadTraceFromFile" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDebugger_LoadTraceFromFile" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpec * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->LoadTraceFromFile(*arg2,(lldb::SBFileSpec const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTrace(result)), SWIGTYPE_p_lldb__SBTrace, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger___repr__" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBDebugger___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetInputFileHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetInputFileHandle" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBDebugger_GetInputFileHandle(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  {
    resultobj = nullptr;
    const lldb::FileSP &sp = result;
    if (sp) {
      PythonFile pyfile = unwrapOrSetPythonException(PythonFile::FromFile(*sp));
      if (!pyfile.IsValid())
      SWIG_fail;
      resultobj = pyfile.release();
    }
    if (!resultobj) {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetOutputFileHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetOutputFileHandle" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBDebugger_GetOutputFileHandle(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  {
    resultobj = nullptr;
    const lldb::FileSP &sp = result;
    if (sp) {
      PythonFile pyfile = unwrapOrSetPythonException(PythonFile::FromFile(*sp));
      if (!pyfile.IsValid())
      SWIG_fail;
      resultobj = pyfile.release();
    }
    if (!resultobj) {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDebugger_GetErrorFileHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDebugger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDebugger_GetErrorFileHandle" "', argument " "1"" of type '" "lldb::SBDebugger *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBDebugger_GetErrorFileHandle(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  {
    resultobj = nullptr;
    const lldb::FileSP &sp = result;
    if (sp) {
      PythonFile pyfile = unwrapOrSetPythonException(PythonFile::FromFile(*sp));
      if (!pyfile.IsValid())
      SWIG_fail;
      resultobj = pyfile.release();
    }
    if (!resultobj) {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBDebugger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBDebugger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBDebugger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBDeclaration__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBDeclaration *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBDeclaration *)new lldb::SBDeclaration();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBDeclaration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBDeclaration__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDeclaration *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBDeclaration *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBDeclaration,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBDeclaration" "', argument " "1"" of type '" "lldb::SBDeclaration const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBDeclaration" "', argument " "1"" of type '" "lldb::SBDeclaration const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDeclaration * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBDeclaration *)new lldb::SBDeclaration((lldb::SBDeclaration const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBDeclaration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBDeclaration(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBDeclaration", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBDeclaration__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBDeclaration, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBDeclaration__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBDeclaration'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBDeclaration::SBDeclaration()\n"
    "    lldb::SBDeclaration::SBDeclaration(lldb::SBDeclaration const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBDeclaration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDeclaration *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDeclaration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBDeclaration" "', argument " "1"" of type '" "lldb::SBDeclaration *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDeclaration * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDeclaration___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDeclaration *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDeclaration___nonzero__" "', argument " "1"" of type '" "lldb::SBDeclaration const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDeclaration * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBDeclaration const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDeclaration_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDeclaration *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDeclaration_IsValid" "', argument " "1"" of type '" "lldb::SBDeclaration const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDeclaration * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBDeclaration const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDeclaration_GetFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDeclaration *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDeclaration_GetFileSpec" "', argument " "1"" of type '" "lldb::SBDeclaration const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDeclaration * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBDeclaration const *)arg1)->GetFileSpec();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDeclaration_GetLine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDeclaration *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDeclaration_GetLine" "', argument " "1"" of type '" "lldb::SBDeclaration const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDeclaration * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBDeclaration const *)arg1)->GetLine();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDeclaration_GetColumn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDeclaration *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDeclaration_GetColumn" "', argument " "1"" of type '" "lldb::SBDeclaration const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDeclaration * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBDeclaration const *)arg1)->GetColumn();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDeclaration_SetFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDeclaration *arg1 = 0 ;
  lldb::SBFileSpec arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDeclaration_SetFileSpec", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDeclaration_SetFileSpec" "', argument " "1"" of type '" "lldb::SBDeclaration *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDeclaration * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDeclaration_SetFileSpec" "', argument " "2"" of type '" "lldb::SBFileSpec""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDeclaration_SetFileSpec" "', argument " "2"" of type '" "lldb::SBFileSpec""'");
    } else {
      lldb::SBFileSpec * temp = reinterpret_cast< lldb::SBFileSpec * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetFileSpec(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDeclaration_SetLine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDeclaration *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDeclaration_SetLine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDeclaration_SetLine" "', argument " "1"" of type '" "lldb::SBDeclaration *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDeclaration * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDeclaration_SetLine" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetLine(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDeclaration_SetColumn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDeclaration *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDeclaration_SetColumn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDeclaration_SetColumn" "', argument " "1"" of type '" "lldb::SBDeclaration *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDeclaration * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBDeclaration_SetColumn" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetColumn(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDeclaration___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDeclaration *arg1 = 0 ;
  lldb::SBDeclaration *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDeclaration___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDeclaration___eq__" "', argument " "1"" of type '" "lldb::SBDeclaration const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDeclaration * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBDeclaration,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDeclaration___eq__" "', argument " "2"" of type '" "lldb::SBDeclaration const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDeclaration___eq__" "', argument " "2"" of type '" "lldb::SBDeclaration const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBDeclaration * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBDeclaration const *)arg1)->operator ==((lldb::SBDeclaration const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBDeclaration___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDeclaration *arg1 = 0 ;
  lldb::SBDeclaration *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDeclaration___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDeclaration___ne__" "', argument " "1"" of type '" "lldb::SBDeclaration const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDeclaration * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBDeclaration,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDeclaration___ne__" "', argument " "2"" of type '" "lldb::SBDeclaration const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDeclaration___ne__" "', argument " "2"" of type '" "lldb::SBDeclaration const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBDeclaration * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBDeclaration const *)arg1)->operator !=((lldb::SBDeclaration const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBDeclaration_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDeclaration *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBDeclaration_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDeclaration_GetDescription" "', argument " "1"" of type '" "lldb::SBDeclaration *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDeclaration * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBDeclaration_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBDeclaration_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBDeclaration___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBDeclaration *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBDeclaration___repr__" "', argument " "1"" of type '" "lldb::SBDeclaration *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDeclaration * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBDeclaration___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBDeclaration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBDeclaration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBDeclaration_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBError *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBError *)new lldb::SBError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBError" "', argument " "1"" of type '" "lldb::SBError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBError" "', argument " "1"" of type '" "lldb::SBError const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBError *)new lldb::SBError((lldb::SBError const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  lldb::SBError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBError" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBError *)new lldb::SBError((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBError", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBError__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBError__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBError__SWIG_2(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBError::SBError()\n"
    "    lldb::SBError::SBError(lldb::SBError const &)\n"
    "    lldb::SBError::SBError(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBError" "', argument " "1"" of type '" "lldb::SBError *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_GetCString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_GetCString" "', argument " "1"" of type '" "lldb::SBError const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBError const *)arg1)->GetCString();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_Clear" "', argument " "1"" of type '" "lldb::SBError *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_Fail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_Fail" "', argument " "1"" of type '" "lldb::SBError const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBError const *)arg1)->Fail();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_Success(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_Success" "', argument " "1"" of type '" "lldb::SBError const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBError const *)arg1)->Success();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_GetError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_GetError" "', argument " "1"" of type '" "lldb::SBError const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBError const *)arg1)->GetError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_GetErrorData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_GetErrorData" "', argument " "1"" of type '" "lldb::SBError const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBError const *)arg1)->GetErrorData();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_GetType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::ErrorType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_GetType" "', argument " "1"" of type '" "lldb::SBError const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ErrorType)((lldb::SBError const *)arg1)->GetType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_SetError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  uint32_t arg2 ;
  lldb::ErrorType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBError_SetError", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_SetError" "', argument " "1"" of type '" "lldb::SBError *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBError_SetError" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBError_SetError" "', argument " "3"" of type '" "lldb::ErrorType""'");
  } 
  arg3 = static_cast< lldb::ErrorType >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetError(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_SetErrorToErrno(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_SetErrorToErrno" "', argument " "1"" of type '" "lldb::SBError *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetErrorToErrno();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_SetErrorToGenericError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_SetErrorToGenericError" "', argument " "1"" of type '" "lldb::SBError *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetErrorToGenericError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_SetErrorString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBError_SetErrorString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_SetErrorString" "', argument " "1"" of type '" "lldb::SBError *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBError_SetErrorString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetErrorString((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_SetErrorStringWithFormat__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  char *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_SetErrorStringWithFormat" "', argument " "1"" of type '" "lldb::SBError *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBError_SetErrorStringWithFormat" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBError_SetErrorStringWithFormat" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBError_SetErrorStringWithFormat" "', argument " "4"" of type '" "char *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBError_SetErrorStringWithFormat" "', argument " "5"" of type '" "char *""'");
  }
  arg5 = reinterpret_cast< char * >(buf5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)(arg1)->SetErrorStringWithFormat((char const *)arg2,arg3,arg4,arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_SetErrorStringWithFormat__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_SetErrorStringWithFormat" "', argument " "1"" of type '" "lldb::SBError *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBError_SetErrorStringWithFormat" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBError_SetErrorStringWithFormat" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBError_SetErrorStringWithFormat" "', argument " "4"" of type '" "char *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)(arg1)->SetErrorStringWithFormat((char const *)arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_SetErrorStringWithFormat__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_SetErrorStringWithFormat" "', argument " "1"" of type '" "lldb::SBError *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBError_SetErrorStringWithFormat" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBError_SetErrorStringWithFormat" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)(arg1)->SetErrorStringWithFormat((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_SetErrorStringWithFormat__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_SetErrorStringWithFormat" "', argument " "1"" of type '" "lldb::SBError *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBError_SetErrorStringWithFormat" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)(arg1)->SetErrorStringWithFormat((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_SetErrorStringWithFormat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBError_SetErrorStringWithFormat", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBError, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBError_SetErrorStringWithFormat__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBError, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBError_SetErrorStringWithFormat__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBError, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBError_SetErrorStringWithFormat__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBError, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SBError_SetErrorStringWithFormat__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBError_SetErrorStringWithFormat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBError::SetErrorStringWithFormat(char const *,char *,char *,char *)\n"
    "    lldb::SBError::SetErrorStringWithFormat(char const *,char *,char *)\n"
    "    lldb::SBError::SetErrorStringWithFormat(char const *,char *)\n"
    "    lldb::SBError::SetErrorStringWithFormat(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBError___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError___nonzero__" "', argument " "1"" of type '" "lldb::SBError const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBError const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_IsValid" "', argument " "1"" of type '" "lldb::SBError const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBError const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBError_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError_GetDescription" "', argument " "1"" of type '" "lldb::SBError *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBError_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBError_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBError___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBError___repr__" "', argument " "1"" of type '" "lldb::SBError *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBError___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBEnvironment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBEnvironment *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBEnvironment *)new lldb::SBEnvironment();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBEnvironment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBEnvironment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBEnvironment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBEnvironment *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEnvironment,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBEnvironment" "', argument " "1"" of type '" "lldb::SBEnvironment const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBEnvironment" "', argument " "1"" of type '" "lldb::SBEnvironment const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEnvironment * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBEnvironment *)new lldb::SBEnvironment((lldb::SBEnvironment const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBEnvironment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBEnvironment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBEnvironment", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBEnvironment__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBEnvironment, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBEnvironment__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBEnvironment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBEnvironment::SBEnvironment()\n"
    "    lldb::SBEnvironment::SBEnvironment(lldb::SBEnvironment const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBEnvironment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEnvironment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEnvironment, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBEnvironment" "', argument " "1"" of type '" "lldb::SBEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEnvironment * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEnvironment_Get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEnvironment *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBEnvironment_Get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEnvironment_Get" "', argument " "1"" of type '" "lldb::SBEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEnvironment * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBEnvironment_Get" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->Get((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEnvironment_GetNumValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEnvironment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEnvironment_GetNumValues" "', argument " "1"" of type '" "lldb::SBEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEnvironment * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetNumValues();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEnvironment_GetNameAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEnvironment *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBEnvironment_GetNameAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEnvironment_GetNameAtIndex" "', argument " "1"" of type '" "lldb::SBEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEnvironment * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBEnvironment_GetNameAtIndex" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetNameAtIndex(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEnvironment_GetValueAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEnvironment *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBEnvironment_GetValueAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEnvironment_GetValueAtIndex" "', argument " "1"" of type '" "lldb::SBEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEnvironment * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBEnvironment_GetValueAtIndex" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetValueAtIndex(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEnvironment_GetEntries(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEnvironment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBStringList result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEnvironment_GetEntries" "', argument " "1"" of type '" "lldb::SBEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEnvironment * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetEntries();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStringList(result)), SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEnvironment_PutEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEnvironment *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBEnvironment_PutEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEnvironment_PutEntry" "', argument " "1"" of type '" "lldb::SBEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEnvironment * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBEnvironment_PutEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->PutEntry((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEnvironment_SetEntries(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEnvironment *arg1 = 0 ;
  lldb::SBStringList *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBEnvironment_SetEntries", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEnvironment_SetEntries" "', argument " "1"" of type '" "lldb::SBEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStringList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBEnvironment_SetEntries" "', argument " "2"" of type '" "lldb::SBStringList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBEnvironment_SetEntries" "', argument " "2"" of type '" "lldb::SBStringList const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBEnvironment_SetEntries" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetEntries((lldb::SBStringList const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEnvironment_Set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEnvironment *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBEnvironment_Set", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEnvironment_Set" "', argument " "1"" of type '" "lldb::SBEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEnvironment * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBEnvironment_Set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBEnvironment_Set" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBEnvironment_Set" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->Set((char const *)arg2,(char const *)arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEnvironment_Unset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEnvironment *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBEnvironment_Unset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEnvironment_Unset" "', argument " "1"" of type '" "lldb::SBEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEnvironment * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBEnvironment_Unset" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->Unset((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEnvironment_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEnvironment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEnvironment_Clear" "', argument " "1"" of type '" "lldb::SBEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEnvironment * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBEnvironment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBEnvironment, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBEnvironment_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBEvent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBEvent *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBEvent *)new lldb::SBEvent();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBEvent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBEvent *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBEvent *)new lldb::SBEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBEvent__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  lldb::SBEvent *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBEvent" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  {
    if (PythonString::Check(swig_obj[1])) {
      PythonString str(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (char *)str.GetString().data();
      arg3 = str.GetSize();
    } else if (PythonByteArray::Check(swig_obj[1])) {
      PythonByteArray bytearray(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (char *)bytearray.GetBytes().data();
      arg3 = bytearray.GetSize();
    } else if (PythonBytes::Check(swig_obj[1])) {
      PythonBytes bytes(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (char *)bytes.GetBytes().data();
      arg3 = bytes.GetSize();
    } else {
      PyErr_SetString(PyExc_ValueError, "Expecting a string");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBEvent *)new lldb::SBEvent(arg1,(char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBEvent", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBEvent__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBEvent__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_new_SBEvent__SWIG_2(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SBEvent__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBEvent::SBEvent()\n"
    "    lldb::SBEvent::SBEvent(lldb::SBEvent const &)\n"
    "    lldb::SBEvent::SBEvent(uint32_t,char const *,uint32_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBEvent" "', argument " "1"" of type '" "lldb::SBEvent *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEvent___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEvent___nonzero__" "', argument " "1"" of type '" "lldb::SBEvent const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBEvent const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEvent_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEvent_IsValid" "', argument " "1"" of type '" "lldb::SBEvent const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBEvent const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEvent_GetDataFlavor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEvent_GetDataFlavor" "', argument " "1"" of type '" "lldb::SBEvent *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetDataFlavor();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEvent_GetType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEvent_GetType" "', argument " "1"" of type '" "lldb::SBEvent const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBEvent const *)arg1)->GetType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEvent_GetBroadcaster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBroadcaster result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEvent_GetBroadcaster" "', argument " "1"" of type '" "lldb::SBEvent const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBEvent const *)arg1)->GetBroadcaster();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBroadcaster(result)), SWIGTYPE_p_lldb__SBBroadcaster, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEvent_GetBroadcasterClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEvent_GetBroadcasterClass" "', argument " "1"" of type '" "lldb::SBEvent const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBEvent const *)arg1)->GetBroadcasterClass();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEvent_BroadcasterMatchesRef(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  lldb::SBBroadcaster *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBEvent_BroadcasterMatchesRef", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEvent_BroadcasterMatchesRef" "', argument " "1"" of type '" "lldb::SBEvent *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBroadcaster,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBEvent_BroadcasterMatchesRef" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBEvent_BroadcasterMatchesRef" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBBroadcaster * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->BroadcasterMatchesRef((lldb::SBBroadcaster const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEvent_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEvent_Clear" "', argument " "1"" of type '" "lldb::SBEvent *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEvent_GetCStringFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEvent_GetCStringFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBEvent_GetCStringFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBEvent::GetCStringFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEvent_GetDescription__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEvent_GetDescription" "', argument " "1"" of type '" "lldb::SBEvent *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBEvent_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBEvent_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEvent_GetDescription__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBEvent_GetDescription" "', argument " "1"" of type '" "lldb::SBEvent const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBEvent_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBEvent_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBEvent const *)arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBEvent_GetDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBEvent_GetDescription", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBEvent, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBEvent_GetDescription__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBEvent, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBEvent_GetDescription__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBEvent_GetDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBEvent::GetDescription(lldb::SBStream &)\n"
    "    lldb::SBEvent::GetDescription(lldb::SBStream &) const\n");
  return 0;
}


SWIGINTERN PyObject *SBEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBEvent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBExecutionContext__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBExecutionContext *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBExecutionContext__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExecutionContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBExecutionContext *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBExecutionContext,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBExecutionContext" "', argument " "1"" of type '" "lldb::SBExecutionContext const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBExecutionContext" "', argument " "1"" of type '" "lldb::SBExecutionContext const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExecutionContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext((lldb::SBExecutionContext const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBExecutionContext__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBExecutionContext *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBExecutionContext" "', argument " "1"" of type '" "lldb::SBTarget const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBExecutionContext" "', argument " "1"" of type '" "lldb::SBTarget const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext((lldb::SBTarget const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBExecutionContext__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBExecutionContext *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBProcess,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBExecutionContext" "', argument " "1"" of type '" "lldb::SBProcess const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBExecutionContext" "', argument " "1"" of type '" "lldb::SBProcess const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext((lldb::SBProcess const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBExecutionContext__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  lldb::SBExecutionContext *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBThread,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBExecutionContext" "', argument " "1"" of type '" "lldb::SBThread""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBExecutionContext" "', argument " "1"" of type '" "lldb::SBThread""'");
    } else {
      lldb::SBThread * temp = reinterpret_cast< lldb::SBThread * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBExecutionContext__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBExecutionContext *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBFrame,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBExecutionContext" "', argument " "1"" of type '" "lldb::SBFrame const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBExecutionContext" "', argument " "1"" of type '" "lldb::SBFrame const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext((lldb::SBFrame const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBExecutionContext(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBExecutionContext", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBExecutionContext__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBExecutionContext__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBExecutionContext__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBExecutionContext__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBExecutionContext__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBExecutionContext__SWIG_5(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBExecutionContext'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBExecutionContext::SBExecutionContext()\n"
    "    lldb::SBExecutionContext::SBExecutionContext(lldb::SBExecutionContext const &)\n"
    "    lldb::SBExecutionContext::SBExecutionContext(lldb::SBTarget const &)\n"
    "    lldb::SBExecutionContext::SBExecutionContext(lldb::SBProcess const &)\n"
    "    lldb::SBExecutionContext::SBExecutionContext(lldb::SBThread)\n"
    "    lldb::SBExecutionContext::SBExecutionContext(lldb::SBFrame const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBExecutionContext(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExecutionContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBExecutionContext" "', argument " "1"" of type '" "lldb::SBExecutionContext *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExecutionContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExecutionContext_GetTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExecutionContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTarget result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExecutionContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExecutionContext_GetTarget" "', argument " "1"" of type '" "lldb::SBExecutionContext const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExecutionContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBExecutionContext const *)arg1)->GetTarget();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExecutionContext_GetProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExecutionContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBProcess result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExecutionContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExecutionContext_GetProcess" "', argument " "1"" of type '" "lldb::SBExecutionContext const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExecutionContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBExecutionContext const *)arg1)->GetProcess();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExecutionContext_GetThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExecutionContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBThread result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExecutionContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExecutionContext_GetThread" "', argument " "1"" of type '" "lldb::SBExecutionContext const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExecutionContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBExecutionContext const *)arg1)->GetThread();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExecutionContext_GetFrame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExecutionContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFrame result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExecutionContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExecutionContext_GetFrame" "', argument " "1"" of type '" "lldb::SBExecutionContext const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExecutionContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBExecutionContext const *)arg1)->GetFrame();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFrame(result)), SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBExecutionContext_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBExecutionContext, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBExecutionContext_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBExpressionOptions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBExpressionOptions *)new lldb::SBExpressionOptions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBExpressionOptions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBExpressionOptions *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBExpressionOptions,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBExpressionOptions" "', argument " "1"" of type '" "lldb::SBExpressionOptions const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBExpressionOptions" "', argument " "1"" of type '" "lldb::SBExpressionOptions const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBExpressionOptions *)new lldb::SBExpressionOptions((lldb::SBExpressionOptions const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBExpressionOptions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBExpressionOptions", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBExpressionOptions__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBExpressionOptions__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBExpressionOptions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBExpressionOptions::SBExpressionOptions()\n"
    "    lldb::SBExpressionOptions::SBExpressionOptions(lldb::SBExpressionOptions const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBExpressionOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBExpressionOptions" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetCoerceResultToId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_GetCoerceResultToId" "', argument " "1"" of type '" "lldb::SBExpressionOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetCoerceResultToId();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetCoerceResultToId__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetCoerceResultToId" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetCoerceResultToId" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetCoerceResultToId(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetCoerceResultToId__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetCoerceResultToId" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetCoerceResultToId();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetCoerceResultToId(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetCoerceResultToId", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBExpressionOptions_SetCoerceResultToId__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBExpressionOptions_SetCoerceResultToId__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBExpressionOptions_SetCoerceResultToId'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBExpressionOptions::SetCoerceResultToId(bool)\n"
    "    lldb::SBExpressionOptions::SetCoerceResultToId()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetUnwindOnError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_GetUnwindOnError" "', argument " "1"" of type '" "lldb::SBExpressionOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetUnwindOnError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetUnwindOnError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetUnwindOnError" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetUnwindOnError" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetUnwindOnError(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetUnwindOnError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetUnwindOnError" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetUnwindOnError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetUnwindOnError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetUnwindOnError", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBExpressionOptions_SetUnwindOnError__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBExpressionOptions_SetUnwindOnError__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBExpressionOptions_SetUnwindOnError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBExpressionOptions::SetUnwindOnError(bool)\n"
    "    lldb::SBExpressionOptions::SetUnwindOnError()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetIgnoreBreakpoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_GetIgnoreBreakpoints" "', argument " "1"" of type '" "lldb::SBExpressionOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetIgnoreBreakpoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetIgnoreBreakpoints__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetIgnoreBreakpoints" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetIgnoreBreakpoints" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetIgnoreBreakpoints(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetIgnoreBreakpoints__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetIgnoreBreakpoints" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetIgnoreBreakpoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetIgnoreBreakpoints(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetIgnoreBreakpoints", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBExpressionOptions_SetIgnoreBreakpoints__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBExpressionOptions_SetIgnoreBreakpoints__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBExpressionOptions_SetIgnoreBreakpoints'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBExpressionOptions::SetIgnoreBreakpoints(bool)\n"
    "    lldb::SBExpressionOptions::SetIgnoreBreakpoints()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetFetchDynamicValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::DynamicValueType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_GetFetchDynamicValue" "', argument " "1"" of type '" "lldb::SBExpressionOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::DynamicValueType)((lldb::SBExpressionOptions const *)arg1)->GetFetchDynamicValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetFetchDynamicValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  lldb::DynamicValueType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetFetchDynamicValue" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetFetchDynamicValue" "', argument " "2"" of type '" "lldb::DynamicValueType""'");
  } 
  arg2 = static_cast< lldb::DynamicValueType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetFetchDynamicValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetFetchDynamicValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetFetchDynamicValue" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetFetchDynamicValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetFetchDynamicValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetFetchDynamicValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBExpressionOptions_SetFetchDynamicValue__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBExpressionOptions_SetFetchDynamicValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBExpressionOptions_SetFetchDynamicValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType)\n"
    "    lldb::SBExpressionOptions::SetFetchDynamicValue()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetTimeoutInMicroSeconds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_GetTimeoutInMicroSeconds" "', argument " "1"" of type '" "lldb::SBExpressionOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBExpressionOptions const *)arg1)->GetTimeoutInMicroSeconds();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTimeoutInMicroSeconds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetTimeoutInMicroSeconds" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetTimeoutInMicroSeconds" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetTimeoutInMicroSeconds(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTimeoutInMicroSeconds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetTimeoutInMicroSeconds" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetTimeoutInMicroSeconds();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTimeoutInMicroSeconds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetTimeoutInMicroSeconds", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBExpressionOptions_SetTimeoutInMicroSeconds__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBExpressionOptions_SetTimeoutInMicroSeconds__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBExpressionOptions_SetTimeoutInMicroSeconds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t)\n"
    "    lldb::SBExpressionOptions::SetTimeoutInMicroSeconds()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetOneThreadTimeoutInMicroSeconds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_GetOneThreadTimeoutInMicroSeconds" "', argument " "1"" of type '" "lldb::SBExpressionOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBExpressionOptions const *)arg1)->GetOneThreadTimeoutInMicroSeconds();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetOneThreadTimeoutInMicroSeconds(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetOneThreadTimeoutInMicroSeconds();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t)\n"
    "    lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetTryAllThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_GetTryAllThreads" "', argument " "1"" of type '" "lldb::SBExpressionOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetTryAllThreads();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTryAllThreads__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetTryAllThreads" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetTryAllThreads" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetTryAllThreads(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTryAllThreads__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetTryAllThreads" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetTryAllThreads();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTryAllThreads(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetTryAllThreads", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBExpressionOptions_SetTryAllThreads__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBExpressionOptions_SetTryAllThreads__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBExpressionOptions_SetTryAllThreads'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBExpressionOptions::SetTryAllThreads(bool)\n"
    "    lldb::SBExpressionOptions::SetTryAllThreads()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetStopOthers(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_GetStopOthers" "', argument " "1"" of type '" "lldb::SBExpressionOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetStopOthers();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetStopOthers__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetStopOthers" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetStopOthers" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetStopOthers(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetStopOthers__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetStopOthers" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetStopOthers();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetStopOthers(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetStopOthers", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBExpressionOptions_SetStopOthers__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBExpressionOptions_SetStopOthers__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBExpressionOptions_SetStopOthers'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBExpressionOptions::SetStopOthers(bool)\n"
    "    lldb::SBExpressionOptions::SetStopOthers()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetTrapExceptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_GetTrapExceptions" "', argument " "1"" of type '" "lldb::SBExpressionOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetTrapExceptions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTrapExceptions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetTrapExceptions" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetTrapExceptions" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetTrapExceptions(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTrapExceptions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetTrapExceptions" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetTrapExceptions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTrapExceptions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetTrapExceptions", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBExpressionOptions_SetTrapExceptions__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBExpressionOptions_SetTrapExceptions__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBExpressionOptions_SetTrapExceptions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBExpressionOptions::SetTrapExceptions(bool)\n"
    "    lldb::SBExpressionOptions::SetTrapExceptions()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetLanguage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  lldb::LanguageType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetLanguage" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetLanguage" "', argument " "2"" of type '" "lldb::LanguageType""'");
  } 
  arg2 = static_cast< lldb::LanguageType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetLanguage(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetLanguage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  lldb::SBSourceLanguageName arg2 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetLanguage" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetLanguage" "', argument " "2"" of type '" "lldb::SBSourceLanguageName""'");
  } 
  arg2 = static_cast< lldb::SBSourceLanguageName >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBExpressionOptions_SetLanguage" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetLanguage(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetLanguage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetLanguage", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBExpressionOptions_SetLanguage__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBExpressionOptions_SetLanguage__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBExpressionOptions_SetLanguage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBExpressionOptions::SetLanguage(lldb::LanguageType)\n"
    "    lldb::SBExpressionOptions::SetLanguage(lldb::SBSourceLanguageName,uint32_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetGenerateDebugInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_GetGenerateDebugInfo" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetGenerateDebugInfo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetGenerateDebugInfo__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetGenerateDebugInfo" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetGenerateDebugInfo" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetGenerateDebugInfo(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetGenerateDebugInfo__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetGenerateDebugInfo" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetGenerateDebugInfo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetGenerateDebugInfo(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetGenerateDebugInfo", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBExpressionOptions_SetGenerateDebugInfo__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBExpressionOptions_SetGenerateDebugInfo__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBExpressionOptions_SetGenerateDebugInfo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBExpressionOptions::SetGenerateDebugInfo(bool)\n"
    "    lldb::SBExpressionOptions::SetGenerateDebugInfo()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetSuppressPersistentResult(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_GetSuppressPersistentResult" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetSuppressPersistentResult();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetSuppressPersistentResult__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetSuppressPersistentResult" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetSuppressPersistentResult" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetSuppressPersistentResult(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetSuppressPersistentResult__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetSuppressPersistentResult" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetSuppressPersistentResult();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetSuppressPersistentResult(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetSuppressPersistentResult", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBExpressionOptions_SetSuppressPersistentResult__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBExpressionOptions_SetSuppressPersistentResult__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBExpressionOptions_SetSuppressPersistentResult'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBExpressionOptions::SetSuppressPersistentResult(bool)\n"
    "    lldb::SBExpressionOptions::SetSuppressPersistentResult()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetPrefix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_GetPrefix" "', argument " "1"" of type '" "lldb::SBExpressionOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBExpressionOptions const *)arg1)->GetPrefix();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetPrefix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetPrefix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetPrefix" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBExpressionOptions_SetPrefix" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetPrefix((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetAutoApplyFixIts__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetAutoApplyFixIts" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetAutoApplyFixIts" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAutoApplyFixIts(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetAutoApplyFixIts__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetAutoApplyFixIts" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAutoApplyFixIts();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetAutoApplyFixIts(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetAutoApplyFixIts", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBExpressionOptions_SetAutoApplyFixIts__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBExpressionOptions_SetAutoApplyFixIts__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBExpressionOptions_SetAutoApplyFixIts'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBExpressionOptions::SetAutoApplyFixIts(bool)\n"
    "    lldb::SBExpressionOptions::SetAutoApplyFixIts()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetAutoApplyFixIts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_GetAutoApplyFixIts" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetAutoApplyFixIts();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetRetriesWithFixIts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetRetriesWithFixIts", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetRetriesWithFixIts" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetRetriesWithFixIts" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetRetriesWithFixIts(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetRetriesWithFixIts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_GetRetriesWithFixIts" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetRetriesWithFixIts();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetTopLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_GetTopLevel" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetTopLevel();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTopLevel__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetTopLevel" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetTopLevel" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetTopLevel(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTopLevel__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetTopLevel" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetTopLevel();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetTopLevel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetTopLevel", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBExpressionOptions_SetTopLevel__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBExpressionOptions_SetTopLevel__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBExpressionOptions_SetTopLevel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBExpressionOptions::SetTopLevel(bool)\n"
    "    lldb::SBExpressionOptions::SetTopLevel()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_GetAllowJIT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_GetAllowJIT" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetAllowJIT();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBExpressionOptions_SetAllowJIT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBExpressionOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBExpressionOptions_SetAllowJIT", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBExpressionOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBExpressionOptions_SetAllowJIT" "', argument " "1"" of type '" "lldb::SBExpressionOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBExpressionOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBExpressionOptions_SetAllowJIT" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAllowJIT(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBExpressionOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBExpressionOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBFile *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFile *)new lldb::SBFile();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg1 ;
  lldb::SBFile *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[0]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp = unwrapOrSetPythonException(py_file.ConvertToFile());
    if (!sp)
    SWIG_fail;
    arg1 = sp;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFile *)new lldb::SBFile(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFile__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  char *arg2 = 0 ;
  bool arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  lldb::SBFile *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBFile" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBFile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SBFile" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFile *)new lldb::SBFile(arg1,(char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NEW |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBFile", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBFile__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      if (PythonFile::Check(argv[0])) {
        _v = 1;
      } else {
        PyErr_Clear();
        _v = 0;
      }
    }
    if (_v) {
      return _wrap_new_SBFile__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SBFile__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBFile::SBFile()\n"
    "    lldb::SBFile::SBFile(lldb::FileSP)\n"
    "    lldb::SBFile::SBFile(int,char const *,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBFile" "', argument " "1"" of type '" "lldb::SBFile *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFile * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFile_Read(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFile *arg1 = 0 ;
  uint8_t *arg2 = 0 ;
  size_t arg3 ;
  size_t *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  arg4 = &temp4;
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFile_Read", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFile_Read" "', argument " "1"" of type '" "lldb::SBFile *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFile * >(argp1);
  {
    if (PythonByteArray::Check(swig_obj[1])) {
      PythonByteArray bytearray(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (uint8_t *)bytearray.GetBytes().data();
      arg3 = bytearray.GetSize();
    } else {
      PyErr_SetString(PyExc_ValueError, "Expecting a bytearray");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Read(arg2,SWIG_STD_MOVE(arg3),arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_size_t((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_size_t, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFile_Write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFile *arg1 = 0 ;
  uint8_t *arg2 = 0 ;
  size_t arg3 ;
  size_t *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  arg4 = &temp4;
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFile_Write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFile_Write" "', argument " "1"" of type '" "lldb::SBFile *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFile * >(argp1);
  {
    if (PythonByteArray::Check(swig_obj[1])) {
      PythonByteArray bytearray(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (uint8_t *)bytearray.GetBytes().data();
      arg3 = bytearray.GetSize();
    } else if (PythonBytes::Check(swig_obj[1])) {
      PythonBytes bytes(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (uint8_t *)bytes.GetBytes().data();
      arg3 = bytes.GetSize();
    } else {
      PyErr_SetString(PyExc_ValueError, "Expecting a bytes or bytearray object");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Write((uint8_t const *)arg2,SWIG_STD_MOVE(arg3),arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_size_t((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_size_t, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFile_Flush(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBError result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFile_Flush" "', argument " "1"" of type '" "lldb::SBFile *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFile * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Flush();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFile_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFile_IsValid" "', argument " "1"" of type '" "lldb::SBFile const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFile * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFile const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFile_Close(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBError result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFile_Close" "', argument " "1"" of type '" "lldb::SBFile *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFile * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Close();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFile___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFile___nonzero__" "', argument " "1"" of type '" "lldb::SBFile const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFile * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFile const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFile_GetFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFile_GetFile" "', argument " "1"" of type '" "lldb::SBFile const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFile * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBFile const *)arg1)->GetFile();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  {
    resultobj = nullptr;
    const lldb::FileSP &sp = result;
    if (sp) {
      PythonFile pyfile = unwrapOrSetPythonException(PythonFile::FromFile(*sp));
      if (!pyfile.IsValid())
      SWIG_fail;
      resultobj = pyfile.release();
    }
    if (!resultobj) {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFile_MakeBorrowed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg1 ;
  PyObject *swig_obj[1] ;
  lldb::SBFile result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[0]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp =
    unwrapOrSetPythonException(py_file.ConvertToFile(/*borrowed=*/true));
    if (!sp)
    SWIG_fail;
    arg1 = sp;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBFile_MakeBorrowed(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFile(result)), SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFile_MakeForcingIOMethods(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg1 ;
  PyObject *swig_obj[1] ;
  lldb::SBFile result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[0]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp = unwrapOrSetPythonException(
      py_file.ConvertToFileForcingUseOfScriptingIOMethods());
    if (!sp)
    SWIG_fail;
    arg1 = sp;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBFile_MakeForcingIOMethods(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFile(result)), SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFile_MakeBorrowedForcingIOMethods(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg1 ;
  PyObject *swig_obj[1] ;
  lldb::SBFile result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[0]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp = unwrapOrSetPythonException(
      py_file.ConvertToFileForcingUseOfScriptingIOMethods(/*borrowed=*/true));
    if (!sp)
    SWIG_fail;
    arg1 = sp;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBFile_MakeBorrowedForcingIOMethods(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFile(result)), SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBFile, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBFileSpec__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFileSpec *)new lldb::SBFileSpec();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFileSpec__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBFileSpec *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBFileSpec" "', argument " "1"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBFileSpec" "', argument " "1"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFileSpec *)new lldb::SBFileSpec((lldb::SBFileSpec const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFileSpec__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  lldb::SBFileSpec *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBFileSpec" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFileSpec *)new lldb::SBFileSpec((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFileSpec__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  bool arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  lldb::SBFileSpec *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBFileSpec" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBFileSpec" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFileSpec *)new lldb::SBFileSpec((char const *)arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFileSpec(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBFileSpec", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBFileSpec__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBFileSpec__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBFileSpec__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SBFileSpec__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBFileSpec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBFileSpec::SBFileSpec()\n"
    "    lldb::SBFileSpec::SBFileSpec(lldb::SBFileSpec const &)\n"
    "    lldb::SBFileSpec::SBFileSpec(char const *)\n"
    "    lldb::SBFileSpec::SBFileSpec(char const *,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBFileSpec" "', argument " "1"" of type '" "lldb::SBFileSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpec___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpec___nonzero__" "', argument " "1"" of type '" "lldb::SBFileSpec const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFileSpec const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpec___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFileSpec___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpec___eq__" "', argument " "1"" of type '" "lldb::SBFileSpec const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpec * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFileSpec___eq__" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFileSpec___eq__" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFileSpec const *)arg1)->operator ==((lldb::SBFileSpec const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBFileSpec___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFileSpec___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpec___ne__" "', argument " "1"" of type '" "lldb::SBFileSpec const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpec * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFileSpec___ne__" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFileSpec___ne__" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFileSpec const *)arg1)->operator !=((lldb::SBFileSpec const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBFileSpec_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpec_IsValid" "', argument " "1"" of type '" "lldb::SBFileSpec const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFileSpec const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpec_Exists(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpec_Exists" "', argument " "1"" of type '" "lldb::SBFileSpec const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFileSpec const *)arg1)->Exists();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpec_ResolveExecutableLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpec_ResolveExecutableLocation" "', argument " "1"" of type '" "lldb::SBFileSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->ResolveExecutableLocation();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpec_GetFilename(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpec_GetFilename" "', argument " "1"" of type '" "lldb::SBFileSpec const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBFileSpec const *)arg1)->GetFilename();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpec_GetDirectory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpec_GetDirectory" "', argument " "1"" of type '" "lldb::SBFileSpec const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBFileSpec const *)arg1)->GetDirectory();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpec_SetFilename(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFileSpec_SetFilename", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpec_SetFilename" "', argument " "1"" of type '" "lldb::SBFileSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpec * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFileSpec_SetFilename" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetFilename((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpec_SetDirectory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFileSpec_SetDirectory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpec_SetDirectory" "', argument " "1"" of type '" "lldb::SBFileSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpec * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFileSpec_SetDirectory" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetDirectory((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpec_GetPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *arg1 = 0 ;
  char *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFileSpec_GetPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpec_GetPath" "', argument " "1"" of type '" "lldb::SBFileSpec const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpec * >(argp1);
  {
    if (!PyLong_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError, "Expecting an integer");
      SWIG_fail;
    }
    arg3 = PyLong_AsLong(swig_obj[1]);
    if (arg3 <= 0) {
      PyErr_SetString(PyExc_ValueError, "Positive integer expected");
      SWIG_fail;
    }
    arg2 = (char *)malloc(arg3);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBFileSpec const *)arg1)->GetPath(arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  {
    Py_XDECREF(resultobj); /* Blow away any previous result */
    llvm::StringRef ref(arg2);
    PythonString string(ref);
    resultobj = string.release();
    free(arg2);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpec_ResolvePath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  size_t arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFileSpec_ResolvePath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpec_ResolvePath" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    if (!PyLong_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError, "Expecting an integer");
      SWIG_fail;
    }
    arg3 = PyLong_AsLong(swig_obj[1]);
    if (arg3 <= 0) {
      PyErr_SetString(PyExc_ValueError, "Positive integer expected");
      SWIG_fail;
    }
    arg2 = (char *)malloc(arg3);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)lldb::SBFileSpec::ResolvePath((char const *)arg1,arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    Py_XDECREF(resultobj); /* Blow away any previous result */
    llvm::StringRef ref(arg2);
    PythonString string(ref);
    resultobj = string.release();
    free(arg2);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpec_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFileSpec_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpec_GetDescription" "', argument " "1"" of type '" "lldb::SBFileSpec const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpec * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFileSpec_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFileSpec_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFileSpec const *)arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpec_AppendPathComponent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFileSpec_AppendPathComponent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpec_AppendPathComponent" "', argument " "1"" of type '" "lldb::SBFileSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpec * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFileSpec_AppendPathComponent" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->AppendPathComponent((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpec___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpec___repr__" "', argument " "1"" of type '" "lldb::SBFileSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBFileSpec___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBFileSpec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBFileSpec, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBFileSpec_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBFileSpecList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBFileSpecList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFileSpecList *)new lldb::SBFileSpecList();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFileSpecList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFileSpecList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBFileSpecList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBFileSpecList" "', argument " "1"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBFileSpecList" "', argument " "1"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpecList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFileSpecList *)new lldb::SBFileSpecList((lldb::SBFileSpecList const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFileSpecList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBFileSpecList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBFileSpecList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBFileSpecList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBFileSpecList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBFileSpecList::SBFileSpecList()\n"
    "    lldb::SBFileSpecList::SBFileSpecList(lldb::SBFileSpecList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBFileSpecList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpecList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBFileSpecList" "', argument " "1"" of type '" "lldb::SBFileSpecList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpecList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpecList_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpecList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpecList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpecList_GetSize" "', argument " "1"" of type '" "lldb::SBFileSpecList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpecList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBFileSpecList const *)arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpecList_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpecList *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFileSpecList_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpecList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpecList_GetDescription" "', argument " "1"" of type '" "lldb::SBFileSpecList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpecList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFileSpecList_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFileSpecList_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFileSpecList const *)arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpecList_Append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpecList *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFileSpecList_Append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpecList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpecList_Append" "', argument " "1"" of type '" "lldb::SBFileSpecList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpecList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFileSpecList_Append" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFileSpecList_Append" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Append((lldb::SBFileSpec const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpecList_AppendIfUnique(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpecList *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFileSpecList_AppendIfUnique", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpecList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpecList_AppendIfUnique" "', argument " "1"" of type '" "lldb::SBFileSpecList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpecList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFileSpecList_AppendIfUnique" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFileSpecList_AppendIfUnique" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->AppendIfUnique((lldb::SBFileSpec const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpecList_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpecList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpecList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpecList_Clear" "', argument " "1"" of type '" "lldb::SBFileSpecList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpecList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpecList_FindFileIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpecList *arg1 = 0 ;
  uint32_t arg2 ;
  lldb::SBFileSpec *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFileSpecList_FindFileIndex", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpecList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpecList_FindFileIndex" "', argument " "1"" of type '" "lldb::SBFileSpecList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpecList * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBFileSpecList_FindFileIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBFileSpecList_FindFileIndex" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFileSpecList_FindFileIndex" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpec * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBFileSpecList_FindFileIndex" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->FindFileIndex(arg2,(lldb::SBFileSpec const &)*arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpecList_GetFileSpecAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpecList *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFileSpecList_GetFileSpecAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpecList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpecList_GetFileSpecAtIndex" "', argument " "1"" of type '" "lldb::SBFileSpecList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpecList * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBFileSpecList_GetFileSpecAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBFileSpecList const *)arg1)->GetFileSpecAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFileSpecList___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpecList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFileSpecList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFileSpecList___repr__" "', argument " "1"" of type '" "lldb::SBFileSpecList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFileSpecList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBFileSpecList___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBFileSpecList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBFileSpecList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBFileSpecList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBFormat__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBFormat *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFormat *)new lldb::SBFormat();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFormat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFormat__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  lldb::SBFormat *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBFormat" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBFormat" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBFormat" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFormat *)new lldb::SBFormat((char const *)arg1,*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFormat, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFormat__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFormat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBFormat *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBFormat,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBFormat" "', argument " "1"" of type '" "lldb::SBFormat const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBFormat" "', argument " "1"" of type '" "lldb::SBFormat const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFormat * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFormat *)new lldb::SBFormat((lldb::SBFormat const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFormat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFormat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBFormat", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBFormat__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBFormat, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBFormat__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SBFormat__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBFormat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBFormat::SBFormat()\n"
    "    lldb::SBFormat::SBFormat(char const *,lldb::SBError &)\n"
    "    lldb::SBFormat::SBFormat(lldb::SBFormat const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFormat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFormat, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBFormat" "', argument " "1"" of type '" "lldb::SBFormat *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFormat * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFormat___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFormat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFormat___nonzero__" "', argument " "1"" of type '" "lldb::SBFormat const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFormat * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFormat const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBFormat, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBFrame__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBFrame *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFrame *)new lldb::SBFrame();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFrame__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBFrame *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBFrame,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBFrame" "', argument " "1"" of type '" "lldb::SBFrame const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBFrame" "', argument " "1"" of type '" "lldb::SBFrame const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFrame *)new lldb::SBFrame((lldb::SBFrame const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFrame(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBFrame", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBFrame__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBFrame__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBFrame'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBFrame::SBFrame()\n"
    "    lldb::SBFrame::SBFrame(lldb::SBFrame const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBFrame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBFrame" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_IsEqual(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  lldb::SBFrame *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFrame_IsEqual", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_IsEqual" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFrame,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame_IsEqual" "', argument " "2"" of type '" "lldb::SBFrame const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFrame_IsEqual" "', argument " "2"" of type '" "lldb::SBFrame const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFrame * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFrame const *)arg1)->IsEqual((lldb::SBFrame const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame___nonzero__" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFrame const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_IsValid" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFrame const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetFrameID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetFrameID" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBFrame const *)arg1)->GetFrameID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetCFA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetCFA" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)((lldb::SBFrame const *)arg1)->GetCFA();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetPC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetPC" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)((lldb::SBFrame const *)arg1)->GetPC();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_SetPC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  lldb::addr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFrame_SetPC", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_SetPC" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBFrame_SetPC" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetPC(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetSP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetSP" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)((lldb::SBFrame const *)arg1)->GetSP();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetFP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetFP" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)((lldb::SBFrame const *)arg1)->GetFP();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetPCAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetPCAddress" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBFrame const *)arg1)->GetPCAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetSymbolContext(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBSymbolContext result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFrame_GetSymbolContext", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetSymbolContext" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBFrame_GetSymbolContext" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBFrame const *)arg1)->GetSymbolContext(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContext(result)), SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBModule result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetModule" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBFrame const *)arg1)->GetModule();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBModule(result)), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetCompileUnit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBCompileUnit result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetCompileUnit" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBFrame const *)arg1)->GetCompileUnit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBCompileUnit(result)), SWIGTYPE_p_lldb__SBCompileUnit, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFunction result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetFunction" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBFrame const *)arg1)->GetFunction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFunction(result)), SWIGTYPE_p_lldb__SBFunction, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetSymbol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBSymbol result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetSymbol" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBFrame const *)arg1)->GetSymbol();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbol(result)), SWIGTYPE_p_lldb__SBSymbol, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetBlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBlock result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetBlock" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBFrame const *)arg1)->GetBlock();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBlock(result)), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetFunctionName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetFunctionName" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetFunctionName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetDisplayFunctionName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetDisplayFunctionName" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetDisplayFunctionName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetFunctionName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetFunctionName" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBFrame const *)arg1)->GetFunctionName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetFunctionName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBFrame_GetFunctionName", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBFrame_GetFunctionName__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBFrame_GetFunctionName__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBFrame_GetFunctionName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBFrame::GetFunctionName()\n"
    "    lldb::SBFrame::GetFunctionName() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBFrame_GuessLanguage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::LanguageType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GuessLanguage" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::LanguageType)((lldb::SBFrame const *)arg1)->GuessLanguage();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_IsInlined__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_IsInlined" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsInlined();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_IsInlined__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_IsInlined" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFrame const *)arg1)->IsInlined();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_IsInlined(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBFrame_IsInlined", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBFrame_IsInlined__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBFrame_IsInlined__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBFrame_IsInlined'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBFrame::IsInlined()\n"
    "    lldb::SBFrame::IsInlined() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBFrame_IsArtificial__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_IsArtificial" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsArtificial();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_IsArtificial__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_IsArtificial" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFrame const *)arg1)->IsArtificial();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_IsArtificial(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBFrame_IsArtificial", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBFrame_IsArtificial__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBFrame_IsArtificial__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBFrame_IsArtificial'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBFrame::IsArtificial()\n"
    "    lldb::SBFrame::IsArtificial() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBFrame_IsSynthetic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_IsSynthetic" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFrame const *)arg1)->IsSynthetic();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_IsHidden(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_IsHidden" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFrame const *)arg1)->IsHidden();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_EvaluateExpression__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_EvaluateExpression" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame_EvaluateExpression" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->EvaluateExpression((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_EvaluateExpression__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::DynamicValueType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_EvaluateExpression" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame_EvaluateExpression" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBFrame_EvaluateExpression" "', argument " "3"" of type '" "lldb::DynamicValueType""'");
  } 
  arg3 = static_cast< lldb::DynamicValueType >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->EvaluateExpression((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_EvaluateExpression__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::DynamicValueType arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_EvaluateExpression" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame_EvaluateExpression" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBFrame_EvaluateExpression" "', argument " "3"" of type '" "lldb::DynamicValueType""'");
  } 
  arg3 = static_cast< lldb::DynamicValueType >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBFrame_EvaluateExpression" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->EvaluateExpression((char const *)arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_EvaluateExpression__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBExpressionOptions *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_EvaluateExpression" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame_EvaluateExpression" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBExpressionOptions,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBFrame_EvaluateExpression" "', argument " "3"" of type '" "lldb::SBExpressionOptions const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFrame_EvaluateExpression" "', argument " "3"" of type '" "lldb::SBExpressionOptions const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBExpressionOptions * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->EvaluateExpression((char const *)arg2,(lldb::SBExpressionOptions const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_EvaluateExpression(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBFrame_EvaluateExpression", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBFrame_EvaluateExpression__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBFrame_EvaluateExpression__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBFrame_EvaluateExpression__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBFrame_EvaluateExpression__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBFrame_EvaluateExpression'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBFrame::EvaluateExpression(char const *)\n"
    "    lldb::SBFrame::EvaluateExpression(char const *,lldb::DynamicValueType)\n"
    "    lldb::SBFrame::EvaluateExpression(char const *,lldb::DynamicValueType,bool)\n"
    "    lldb::SBFrame::EvaluateExpression(char const *,lldb::SBExpressionOptions const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetLanguageSpecificData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetLanguageSpecificData" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBFrame const *)arg1)->GetLanguageSpecificData();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetFrameBlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBlock result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetFrameBlock" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBFrame const *)arg1)->GetFrameBlock();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBlock(result)), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetLineEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBLineEntry result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetLineEntry" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBFrame const *)arg1)->GetLineEntry();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBLineEntry(result)), SWIGTYPE_p_lldb__SBLineEntry, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBThread result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetThread" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBFrame const *)arg1)->GetThread();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_Disassemble(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_Disassemble" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBFrame const *)arg1)->Disassemble();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_Clear" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  lldb::SBFrame *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFrame___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame___eq__" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFrame,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame___eq__" "', argument " "2"" of type '" "lldb::SBFrame const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFrame___eq__" "', argument " "2"" of type '" "lldb::SBFrame const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFrame * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFrame const *)arg1)->operator ==((lldb::SBFrame const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBFrame___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  lldb::SBFrame *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFrame___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame___ne__" "', argument " "1"" of type '" "lldb::SBFrame const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFrame,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame___ne__" "', argument " "2"" of type '" "lldb::SBFrame const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFrame___ne__" "', argument " "2"" of type '" "lldb::SBFrame const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFrame * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFrame const *)arg1)->operator !=((lldb::SBFrame const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetVariables__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  lldb::SBValueList result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetVariables" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBFrame_GetVariables" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBFrame_GetVariables" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBFrame_GetVariables" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBFrame_GetVariables" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetVariables(arg2,arg3,arg4,arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValueList(result)), SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetVariables__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  lldb::DynamicValueType arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  lldb::SBValueList result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetVariables" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBFrame_GetVariables" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBFrame_GetVariables" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBFrame_GetVariables" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBFrame_GetVariables" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBFrame_GetVariables" "', argument " "6"" of type '" "lldb::DynamicValueType""'");
  } 
  arg6 = static_cast< lldb::DynamicValueType >(val6);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetVariables(arg2,arg3,arg4,arg5,arg6);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValueList(result)), SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetVariables__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  lldb::SBVariablesOptions *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  lldb::SBValueList result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetVariables" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBVariablesOptions,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame_GetVariables" "', argument " "2"" of type '" "lldb::SBVariablesOptions const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFrame_GetVariables" "', argument " "2"" of type '" "lldb::SBVariablesOptions const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBVariablesOptions * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetVariables((lldb::SBVariablesOptions const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValueList(result)), SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetVariables(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBFrame_GetVariables", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBVariablesOptions, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBFrame_GetVariables__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SBFrame_GetVariables__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SBFrame_GetVariables__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBFrame_GetVariables'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBFrame::GetVariables(bool,bool,bool,bool)\n"
    "    lldb::SBFrame::GetVariables(bool,bool,bool,bool,lldb::DynamicValueType)\n"
    "    lldb::SBFrame::GetVariables(lldb::SBVariablesOptions const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetRegisters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBValueList result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetRegisters" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetRegisters();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValueList(result)), SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_FindRegister(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFrame_FindRegister", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_FindRegister" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame_FindRegister" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindRegister((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_FindVariable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_FindVariable" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame_FindVariable" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindVariable((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_FindVariable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::DynamicValueType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_FindVariable" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame_FindVariable" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBFrame_FindVariable" "', argument " "3"" of type '" "lldb::DynamicValueType""'");
  } 
  arg3 = static_cast< lldb::DynamicValueType >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindVariable((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_FindVariable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBFrame_FindVariable", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBFrame_FindVariable__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBFrame_FindVariable__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBFrame_FindVariable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBFrame::FindVariable(char const *)\n"
    "    lldb::SBFrame::FindVariable(char const *,lldb::DynamicValueType)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetValueForVariablePath__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::DynamicValueType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetValueForVariablePath" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame_GetValueForVariablePath" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBFrame_GetValueForVariablePath" "', argument " "3"" of type '" "lldb::DynamicValueType""'");
  } 
  arg3 = static_cast< lldb::DynamicValueType >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetValueForVariablePath((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetValueForVariablePath__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetValueForVariablePath" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame_GetValueForVariablePath" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetValueForVariablePath((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetValueForVariablePath(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBFrame_GetValueForVariablePath", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBFrame_GetValueForVariablePath__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBFrame_GetValueForVariablePath__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBFrame_GetValueForVariablePath'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBFrame::GetValueForVariablePath(char const *,lldb::DynamicValueType)\n"
    "    lldb::SBFrame::GetValueForVariablePath(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBFrame_FindValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::ValueType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_FindValue" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame_FindValue" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBFrame_FindValue" "', argument " "3"" of type '" "lldb::ValueType""'");
  } 
  arg3 = static_cast< lldb::ValueType >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindValue((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_FindValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::ValueType arg3 ;
  lldb::DynamicValueType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_FindValue" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame_FindValue" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBFrame_FindValue" "', argument " "3"" of type '" "lldb::ValueType""'");
  } 
  arg3 = static_cast< lldb::ValueType >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBFrame_FindValue" "', argument " "4"" of type '" "lldb::DynamicValueType""'");
  } 
  arg4 = static_cast< lldb::DynamicValueType >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindValue((char const *)arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_FindValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBFrame_FindValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBFrame_FindValue__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBFrame_FindValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBFrame_FindValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBFrame::FindValue(char const *,lldb::ValueType)\n"
    "    lldb::SBFrame::FindValue(char const *,lldb::ValueType,lldb::DynamicValueType)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFrame_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetDescription" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFrame_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame_GetDescriptionWithFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  lldb::SBFormat *arg2 = 0 ;
  lldb::SBStream *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFrame_GetDescriptionWithFormat", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame_GetDescriptionWithFormat" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFormat,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrame_GetDescriptionWithFormat" "', argument " "2"" of type '" "lldb::SBFormat const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFrame_GetDescriptionWithFormat" "', argument " "2"" of type '" "lldb::SBFormat const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFormat * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBFrame_GetDescriptionWithFormat" "', argument " "3"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFrame_GetDescriptionWithFormat" "', argument " "3"" of type '" "lldb::SBStream &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBStream * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetDescriptionWithFormat((lldb::SBFormat const &)*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrame___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrame *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrame___repr__" "', argument " "1"" of type '" "lldb::SBFrame *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrame * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBFrame___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBFrame_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBFrame, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBFrame_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBFrameList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBFrameList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFrameList *)new lldb::SBFrameList();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFrameList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFrameList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFrameList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBFrameList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBFrameList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBFrameList" "', argument " "1"" of type '" "lldb::SBFrameList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBFrameList" "', argument " "1"" of type '" "lldb::SBFrameList const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFrameList *)new lldb::SBFrameList((lldb::SBFrameList const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFrameList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFrameList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBFrameList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBFrameList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBFrameList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBFrameList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBFrameList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBFrameList::SBFrameList()\n"
    "    lldb::SBFrameList::SBFrameList(lldb::SBFrameList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBFrameList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrameList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBFrameList" "', argument " "1"" of type '" "lldb::SBFrameList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrameList___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrameList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrameList___nonzero__" "', argument " "1"" of type '" "lldb::SBFrameList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFrameList const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrameList_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrameList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrameList_IsValid" "', argument " "1"" of type '" "lldb::SBFrameList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFrameList const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrameList_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrameList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrameList_GetSize" "', argument " "1"" of type '" "lldb::SBFrameList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBFrameList const *)arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrameList_GetFrameAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrameList *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBFrame result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFrameList_GetFrameAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrameList_GetFrameAtIndex" "', argument " "1"" of type '" "lldb::SBFrameList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBFrameList_GetFrameAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBFrameList const *)arg1)->GetFrameAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFrame(result)), SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrameList_GetThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrameList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBThread result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrameList_GetThread" "', argument " "1"" of type '" "lldb::SBFrameList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBFrameList const *)arg1)->GetThread();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrameList_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrameList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrameList_Clear" "', argument " "1"" of type '" "lldb::SBFrameList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrameList_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrameList *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFrameList_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrameList_GetDescription" "', argument " "1"" of type '" "lldb::SBFrameList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFrameList_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFrameList_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFrameList const *)arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFrameList___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFrameList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFrameList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFrameList___str__" "', argument " "1"" of type '" "lldb::SBFrameList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFrameList * >(argp1);
  result = lldb_SBFrameList___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBFrameList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBFrameList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBFrameList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBFunction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBFunction *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFunction *)new lldb::SBFunction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFunction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBFunction *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBFunction,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBFunction" "', argument " "1"" of type '" "lldb::SBFunction const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBFunction" "', argument " "1"" of type '" "lldb::SBFunction const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBFunction *)new lldb::SBFunction((lldb::SBFunction const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBFunction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBFunction", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBFunction__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBFunction, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBFunction__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBFunction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBFunction::SBFunction()\n"
    "    lldb::SBFunction::SBFunction(lldb::SBFunction const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBFunction" "', argument " "1"" of type '" "lldb::SBFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction___nonzero__" "', argument " "1"" of type '" "lldb::SBFunction const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFunction const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_IsValid" "', argument " "1"" of type '" "lldb::SBFunction const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFunction const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_GetName" "', argument " "1"" of type '" "lldb::SBFunction const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBFunction const *)arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetDisplayName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_GetDisplayName" "', argument " "1"" of type '" "lldb::SBFunction const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBFunction const *)arg1)->GetDisplayName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetMangledName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_GetMangledName" "', argument " "1"" of type '" "lldb::SBFunction const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBFunction const *)arg1)->GetMangledName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetBaseName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_GetBaseName" "', argument " "1"" of type '" "lldb::SBFunction const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBFunction const *)arg1)->GetBaseName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetInstructions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  lldb::SBTarget arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  lldb::SBInstructionList result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_GetInstructions" "', argument " "1"" of type '" "lldb::SBFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFunction_GetInstructions" "', argument " "2"" of type '" "lldb::SBTarget""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFunction_GetInstructions" "', argument " "2"" of type '" "lldb::SBTarget""'");
    } else {
      lldb::SBTarget * temp = reinterpret_cast< lldb::SBTarget * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetInstructions(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBInstructionList(result)), SWIGTYPE_p_lldb__SBInstructionList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetInstructions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  lldb::SBTarget arg2 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  lldb::SBInstructionList result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_GetInstructions" "', argument " "1"" of type '" "lldb::SBFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFunction_GetInstructions" "', argument " "2"" of type '" "lldb::SBTarget""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFunction_GetInstructions" "', argument " "2"" of type '" "lldb::SBTarget""'");
    } else {
      lldb::SBTarget * temp = reinterpret_cast< lldb::SBTarget * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBFunction_GetInstructions" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetInstructions(SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBInstructionList(result)), SWIGTYPE_p_lldb__SBInstructionList, SWIG_POINTER_OWN |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetInstructions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBFunction_GetInstructions", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFunction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBFunction_GetInstructions__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBFunction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBFunction_GetInstructions__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBFunction_GetInstructions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBFunction::GetInstructions(lldb::SBTarget)\n"
    "    lldb::SBFunction::GetInstructions(lldb::SBTarget,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetStartAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_GetStartAddress" "', argument " "1"" of type '" "lldb::SBFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetStartAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetEndAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_GetEndAddress" "', argument " "1"" of type '" "lldb::SBFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetEndAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetRanges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBAddressRangeList result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_GetRanges" "', argument " "1"" of type '" "lldb::SBFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetRanges();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddressRangeList(result)), SWIGTYPE_p_lldb__SBAddressRangeList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetArgumentName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFunction_GetArgumentName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_GetArgumentName" "', argument " "1"" of type '" "lldb::SBFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBFunction_GetArgumentName" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetArgumentName(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetPrologueByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_GetPrologueByteSize" "', argument " "1"" of type '" "lldb::SBFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetPrologueByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_GetType" "', argument " "1"" of type '" "lldb::SBFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetBlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBlock result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_GetBlock" "', argument " "1"" of type '" "lldb::SBFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetBlock();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBlock(result)), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetLanguage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::LanguageType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_GetLanguage" "', argument " "1"" of type '" "lldb::SBFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::LanguageType)(arg1)->GetLanguage();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetIsOptimized(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_GetIsOptimized" "', argument " "1"" of type '" "lldb::SBFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetIsOptimized();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  lldb::SBFunction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFunction___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction___eq__" "', argument " "1"" of type '" "lldb::SBFunction const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFunction,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFunction___eq__" "', argument " "2"" of type '" "lldb::SBFunction const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFunction___eq__" "', argument " "2"" of type '" "lldb::SBFunction const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFunction * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFunction const *)arg1)->operator ==((lldb::SBFunction const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBFunction___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  lldb::SBFunction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFunction___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction___ne__" "', argument " "1"" of type '" "lldb::SBFunction const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFunction,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFunction___ne__" "', argument " "2"" of type '" "lldb::SBFunction const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFunction___ne__" "', argument " "2"" of type '" "lldb::SBFunction const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFunction * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBFunction const *)arg1)->operator !=((lldb::SBFunction const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBFunction_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBFunction_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction_GetDescription" "', argument " "1"" of type '" "lldb::SBFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBFunction_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBFunction_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBFunction___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBFunction___repr__" "', argument " "1"" of type '" "lldb::SBFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBFunction___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBFunction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBFunction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBFunction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBHostOS_GetProgramFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBHostOS_GetProgramFileSpec", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBHostOS::GetProgramFileSpec();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBHostOS_GetLLDBPythonPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBHostOS_GetLLDBPythonPath", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBHostOS::GetLLDBPythonPath();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBHostOS_GetLLDBPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::PathType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBHostOS_GetLLDBPath" "', argument " "1"" of type '" "lldb::PathType""'");
  } 
  arg1 = static_cast< lldb::PathType >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBHostOS::GetLLDBPath(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBHostOS_GetUserHomeDirectory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBHostOS_GetUserHomeDirectory", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBHostOS::GetUserHomeDirectory();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBHostOS_ThreadCreated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBHostOS_ThreadCreated" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb::SBHostOS::ThreadCreated((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBHostOS_ThreadCreate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  lldb::thread_func_t arg2 = 0 ;
  void *arg3 = 0 ;
  lldb::SBError *arg4 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  lldb::thread_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBHostOS_ThreadCreate", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBHostOS_ThreadCreate" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void__p_void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SBHostOS_ThreadCreate" "', argument " "2"" of type '" "lldb::thread_func_t""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBHostOS_ThreadCreate" "', argument " "3"" of type '" "void *""'"); 
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBHostOS_ThreadCreate" "', argument " "4"" of type '" "lldb::SBError *""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBError * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBHostOS::ThreadCreate((char const *)arg1,arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::thread_t(result)), SWIGTYPE_p_pthread_t, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBHostOS_ThreadCancel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::thread_t arg1 ;
  lldb::SBError *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBHostOS_ThreadCancel", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_pthread_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBHostOS_ThreadCancel" "', argument " "1"" of type '" "lldb::thread_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBHostOS_ThreadCancel" "', argument " "1"" of type '" "lldb::thread_t""'");
    } else {
      lldb::thread_t * temp = reinterpret_cast< lldb::thread_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBHostOS_ThreadCancel" "', argument " "2"" of type '" "lldb::SBError *""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBHostOS::ThreadCancel(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBHostOS_ThreadDetach(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::thread_t arg1 ;
  lldb::SBError *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBHostOS_ThreadDetach", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_pthread_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBHostOS_ThreadDetach" "', argument " "1"" of type '" "lldb::thread_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBHostOS_ThreadDetach" "', argument " "1"" of type '" "lldb::thread_t""'");
    } else {
      lldb::thread_t * temp = reinterpret_cast< lldb::thread_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBHostOS_ThreadDetach" "', argument " "2"" of type '" "lldb::SBError *""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBHostOS::ThreadDetach(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBHostOS_ThreadJoin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::thread_t arg1 ;
  lldb::thread_result_t *arg2 = 0 ;
  lldb::SBError *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBHostOS_ThreadJoin", 3, 3, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_pthread_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBHostOS_ThreadJoin" "', argument " "1"" of type '" "lldb::thread_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBHostOS_ThreadJoin" "', argument " "1"" of type '" "lldb::thread_t""'");
    } else {
      lldb::thread_t * temp = reinterpret_cast< lldb::thread_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_void, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBHostOS_ThreadJoin" "', argument " "2"" of type '" "lldb::thread_result_t *""'"); 
  }
  arg2 = reinterpret_cast< lldb::thread_result_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_lldb__SBError, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBHostOS_ThreadJoin" "', argument " "3"" of type '" "lldb::SBError *""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBError * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBHostOS::ThreadJoin(SWIG_STD_MOVE(arg1),arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBHostOS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBHostOS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SBHostOS", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBHostOS *)new lldb::SBHostOS();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBHostOS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBHostOS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBHostOS *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBHostOS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBHostOS" "', argument " "1"" of type '" "lldb::SBHostOS *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBHostOS * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBHostOS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBHostOS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBHostOS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBInstruction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBInstruction *)new lldb::SBInstruction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBInstruction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBInstruction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBInstruction *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBInstruction,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBInstruction" "', argument " "1"" of type '" "lldb::SBInstruction const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBInstruction" "', argument " "1"" of type '" "lldb::SBInstruction const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBInstruction *)new lldb::SBInstruction((lldb::SBInstruction const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBInstruction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBInstruction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBInstruction", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBInstruction__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBInstruction, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBInstruction__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBInstruction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBInstruction::SBInstruction()\n"
    "    lldb::SBInstruction::SBInstruction(lldb::SBInstruction const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBInstruction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBInstruction" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction___nonzero__" "', argument " "1"" of type '" "lldb::SBInstruction const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBInstruction const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_IsValid" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_GetAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_GetAddress" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_GetMnemonic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  lldb::SBTarget arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBInstruction_GetMnemonic", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_GetMnemonic" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstruction_GetMnemonic" "', argument " "2"" of type '" "lldb::SBTarget""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstruction_GetMnemonic" "', argument " "2"" of type '" "lldb::SBTarget""'");
    } else {
      lldb::SBTarget * temp = reinterpret_cast< lldb::SBTarget * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetMnemonic(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_GetOperands(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  lldb::SBTarget arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBInstruction_GetOperands", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_GetOperands" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstruction_GetOperands" "', argument " "2"" of type '" "lldb::SBTarget""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstruction_GetOperands" "', argument " "2"" of type '" "lldb::SBTarget""'");
    } else {
      lldb::SBTarget * temp = reinterpret_cast< lldb::SBTarget * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetOperands(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_GetComment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  lldb::SBTarget arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBInstruction_GetComment", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_GetComment" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstruction_GetComment" "', argument " "2"" of type '" "lldb::SBTarget""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstruction_GetComment" "', argument " "2"" of type '" "lldb::SBTarget""'");
    } else {
      lldb::SBTarget * temp = reinterpret_cast< lldb::SBTarget * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetComment(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_GetControlFlowKind(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  lldb::SBTarget arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::InstructionControlFlowKind result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBInstruction_GetControlFlowKind", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_GetControlFlowKind" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstruction_GetControlFlowKind" "', argument " "2"" of type '" "lldb::SBTarget""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstruction_GetControlFlowKind" "', argument " "2"" of type '" "lldb::SBTarget""'");
    } else {
      lldb::SBTarget * temp = reinterpret_cast< lldb::SBTarget * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::InstructionControlFlowKind)(arg1)->GetControlFlowKind(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_GetData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  lldb::SBTarget arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBData result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBInstruction_GetData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_GetData" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstruction_GetData" "', argument " "2"" of type '" "lldb::SBTarget""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstruction_GetData" "', argument " "2"" of type '" "lldb::SBTarget""'");
    } else {
      lldb::SBTarget * temp = reinterpret_cast< lldb::SBTarget * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetData(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBData(result)), SWIGTYPE_p_lldb__SBData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_GetByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_GetByteSize" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_DoesBranch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_DoesBranch" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->DoesBranch();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_HasDelaySlot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_HasDelaySlot" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->HasDelaySlot();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_CanSetBreakpoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_CanSetBreakpoint" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->CanSetBreakpoint();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_Print__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  lldb::SBFile arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_Print" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFile,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstruction_Print" "', argument " "2"" of type '" "lldb::SBFile""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstruction_Print" "', argument " "2"" of type '" "lldb::SBFile""'");
    } else {
      lldb::SBFile * temp = reinterpret_cast< lldb::SBFile * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Print(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_Print__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_Print" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[1]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp =
    unwrapOrSetPythonException(py_file.ConvertToFile(/*borrowed=*/true));
    if (!sp)
    SWIG_fail;
    arg2 = sp;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Print(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_Print(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBInstruction_Print", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBInstruction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBInstruction_Print__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBInstruction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        if (PythonFile::Check(argv[1])) {
          _v = 1;
        } else {
          PyErr_Clear();
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SBInstruction_Print__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBInstruction_Print'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBInstruction::Print(lldb::SBFile)\n"
    "    lldb::SBInstruction::Print(lldb::FileSP)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBInstruction_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBInstruction_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_GetDescription" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstruction_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstruction_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_EmulateWithFrame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  lldb::SBFrame *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBInstruction_EmulateWithFrame", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_EmulateWithFrame" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFrame,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstruction_EmulateWithFrame" "', argument " "2"" of type '" "lldb::SBFrame &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstruction_EmulateWithFrame" "', argument " "2"" of type '" "lldb::SBFrame &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFrame * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBInstruction_EmulateWithFrame" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->EmulateWithFrame(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_DumpEmulation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBInstruction_DumpEmulation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_DumpEmulation" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstruction_DumpEmulation" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->DumpEmulation((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction_TestEmulation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBInstruction_TestEmulation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction_TestEmulation" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstruction_TestEmulation" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstruction_TestEmulation" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBInstruction_TestEmulation" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->TestEmulation(*arg2,(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstruction___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstruction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstruction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstruction___repr__" "', argument " "1"" of type '" "lldb::SBInstruction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstruction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBInstruction___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBInstruction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBInstruction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBInstruction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBInstructionList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBInstructionList *)new lldb::SBInstructionList();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBInstructionList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBInstructionList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBInstructionList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBInstructionList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBInstructionList" "', argument " "1"" of type '" "lldb::SBInstructionList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBInstructionList" "', argument " "1"" of type '" "lldb::SBInstructionList const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstructionList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBInstructionList *)new lldb::SBInstructionList((lldb::SBInstructionList const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBInstructionList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBInstructionList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBInstructionList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBInstructionList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBInstructionList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBInstructionList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBInstructionList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBInstructionList::SBInstructionList()\n"
    "    lldb::SBInstructionList::SBInstructionList(lldb::SBInstructionList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBInstructionList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstructionList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBInstructionList" "', argument " "1"" of type '" "lldb::SBInstructionList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstructionList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstructionList___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstructionList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstructionList___nonzero__" "', argument " "1"" of type '" "lldb::SBInstructionList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstructionList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBInstructionList const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstructionList_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstructionList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstructionList_IsValid" "', argument " "1"" of type '" "lldb::SBInstructionList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstructionList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBInstructionList const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstructionList_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstructionList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstructionList_GetSize" "', argument " "1"" of type '" "lldb::SBInstructionList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstructionList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstructionList_GetInstructionAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBInstruction result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBInstructionList_GetInstructionAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstructionList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstructionList_GetInstructionAtIndex" "', argument " "1"" of type '" "lldb::SBInstructionList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstructionList * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBInstructionList_GetInstructionAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetInstructionAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBInstruction(result)), SWIGTYPE_p_lldb__SBInstruction, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstructionList_GetInstructionsCount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *arg1 = 0 ;
  lldb::SBAddress *arg2 = 0 ;
  lldb::SBAddress *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  size_t result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstructionList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstructionList_GetInstructionsCount" "', argument " "1"" of type '" "lldb::SBInstructionList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstructionList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstructionList_GetInstructionsCount" "', argument " "2"" of type '" "lldb::SBAddress const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstructionList_GetInstructionsCount" "', argument " "2"" of type '" "lldb::SBAddress const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAddress * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBInstructionList_GetInstructionsCount" "', argument " "3"" of type '" "lldb::SBAddress const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstructionList_GetInstructionsCount" "', argument " "3"" of type '" "lldb::SBAddress const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBAddress * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBInstructionList_GetInstructionsCount" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetInstructionsCount((lldb::SBAddress const &)*arg2,(lldb::SBAddress const &)*arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstructionList_GetInstructionsCount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *arg1 = 0 ;
  lldb::SBAddress *arg2 = 0 ;
  lldb::SBAddress *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstructionList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstructionList_GetInstructionsCount" "', argument " "1"" of type '" "lldb::SBInstructionList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstructionList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstructionList_GetInstructionsCount" "', argument " "2"" of type '" "lldb::SBAddress const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstructionList_GetInstructionsCount" "', argument " "2"" of type '" "lldb::SBAddress const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAddress * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBInstructionList_GetInstructionsCount" "', argument " "3"" of type '" "lldb::SBAddress const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstructionList_GetInstructionsCount" "', argument " "3"" of type '" "lldb::SBAddress const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBAddress * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetInstructionsCount((lldb::SBAddress const &)*arg2,(lldb::SBAddress const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstructionList_GetInstructionsCount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBInstructionList_GetInstructionsCount", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBInstructionList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBInstructionList_GetInstructionsCount__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBInstructionList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBInstructionList_GetInstructionsCount__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBInstructionList_GetInstructionsCount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBInstructionList::GetInstructionsCount(lldb::SBAddress const &,lldb::SBAddress const &,bool)\n"
    "    lldb::SBInstructionList::GetInstructionsCount(lldb::SBAddress const &,lldb::SBAddress const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBInstructionList_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstructionList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstructionList_Clear" "', argument " "1"" of type '" "lldb::SBInstructionList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstructionList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstructionList_AppendInstruction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *arg1 = 0 ;
  lldb::SBInstruction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBInstructionList_AppendInstruction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstructionList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstructionList_AppendInstruction" "', argument " "1"" of type '" "lldb::SBInstructionList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstructionList * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBInstruction,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstructionList_AppendInstruction" "', argument " "2"" of type '" "lldb::SBInstruction""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstructionList_AppendInstruction" "', argument " "2"" of type '" "lldb::SBInstruction""'");
    } else {
      lldb::SBInstruction * temp = reinterpret_cast< lldb::SBInstruction * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->AppendInstruction(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstructionList_Print__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *arg1 = 0 ;
  lldb::SBFile arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstructionList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstructionList_Print" "', argument " "1"" of type '" "lldb::SBInstructionList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstructionList * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFile,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstructionList_Print" "', argument " "2"" of type '" "lldb::SBFile""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstructionList_Print" "', argument " "2"" of type '" "lldb::SBFile""'");
    } else {
      lldb::SBFile * temp = reinterpret_cast< lldb::SBFile * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Print(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstructionList_Print__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *arg1 = 0 ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstructionList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstructionList_Print" "', argument " "1"" of type '" "lldb::SBInstructionList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstructionList * >(argp1);
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[1]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp =
    unwrapOrSetPythonException(py_file.ConvertToFile(/*borrowed=*/true));
    if (!sp)
    SWIG_fail;
    arg2 = sp;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Print(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstructionList_Print(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBInstructionList_Print", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBInstructionList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBInstructionList_Print__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBInstructionList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        if (PythonFile::Check(argv[1])) {
          _v = 1;
        } else {
          PyErr_Clear();
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SBInstructionList_Print__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBInstructionList_Print'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBInstructionList::Print(lldb::SBFile)\n"
    "    lldb::SBInstructionList::Print(lldb::FileSP)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBInstructionList_GetDescription__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstructionList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstructionList_GetDescription" "', argument " "1"" of type '" "lldb::SBInstructionList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstructionList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstructionList_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstructionList_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstructionList_GetDescription__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::SBExecutionContext *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstructionList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstructionList_GetDescription" "', argument " "1"" of type '" "lldb::SBInstructionList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstructionList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstructionList_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstructionList_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBExecutionContext,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBInstructionList_GetDescription" "', argument " "3"" of type '" "lldb::SBExecutionContext &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBInstructionList_GetDescription" "', argument " "3"" of type '" "lldb::SBExecutionContext &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBExecutionContext * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstructionList_GetDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBInstructionList_GetDescription", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBInstructionList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBInstructionList_GetDescription__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBInstructionList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBInstructionList_GetDescription__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBInstructionList_GetDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBInstructionList::GetDescription(lldb::SBStream &)\n"
    "    lldb::SBInstructionList::GetDescription(lldb::SBStream &,lldb::SBExecutionContext &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBInstructionList_DumpEmulationForAllInstructions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBInstructionList_DumpEmulationForAllInstructions", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstructionList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstructionList_DumpEmulationForAllInstructions" "', argument " "1"" of type '" "lldb::SBInstructionList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstructionList * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBInstructionList_DumpEmulationForAllInstructions" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->DumpEmulationForAllInstructions((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBInstructionList___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBInstructionList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBInstructionList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBInstructionList___repr__" "', argument " "1"" of type '" "lldb::SBInstructionList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBInstructionList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBInstructionList___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBInstructionList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBInstructionList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBInstructionList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBLanguageRuntime_GetLanguageTypeFromString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::LanguageType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLanguageRuntime_GetLanguageTypeFromString" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::LanguageType)lldb::SBLanguageRuntime::GetLanguageTypeFromString((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLanguageRuntime_GetNameForLanguageType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::LanguageType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBLanguageRuntime_GetNameForLanguageType" "', argument " "1"" of type '" "lldb::LanguageType""'");
  } 
  arg1 = static_cast< lldb::LanguageType >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBLanguageRuntime::GetNameForLanguageType(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLanguageRuntime_LanguageIsCPlusPlus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::LanguageType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBLanguageRuntime_LanguageIsCPlusPlus" "', argument " "1"" of type '" "lldb::LanguageType""'");
  } 
  arg1 = static_cast< lldb::LanguageType >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBLanguageRuntime::LanguageIsCPlusPlus(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLanguageRuntime_LanguageIsObjC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::LanguageType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBLanguageRuntime_LanguageIsObjC" "', argument " "1"" of type '" "lldb::LanguageType""'");
  } 
  arg1 = static_cast< lldb::LanguageType >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBLanguageRuntime::LanguageIsObjC(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLanguageRuntime_LanguageIsCFamily(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::LanguageType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBLanguageRuntime_LanguageIsCFamily" "', argument " "1"" of type '" "lldb::LanguageType""'");
  } 
  arg1 = static_cast< lldb::LanguageType >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBLanguageRuntime::LanguageIsCFamily(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLanguageRuntime_SupportsExceptionBreakpointsOnThrow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::LanguageType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBLanguageRuntime_SupportsExceptionBreakpointsOnThrow" "', argument " "1"" of type '" "lldb::LanguageType""'");
  } 
  arg1 = static_cast< lldb::LanguageType >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBLanguageRuntime::SupportsExceptionBreakpointsOnThrow(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLanguageRuntime_SupportsExceptionBreakpointsOnCatch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::LanguageType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBLanguageRuntime_SupportsExceptionBreakpointsOnCatch" "', argument " "1"" of type '" "lldb::LanguageType""'");
  } 
  arg1 = static_cast< lldb::LanguageType >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBLanguageRuntime::SupportsExceptionBreakpointsOnCatch(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLanguageRuntime_GetThrowKeywordForLanguage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::LanguageType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBLanguageRuntime_GetThrowKeywordForLanguage" "', argument " "1"" of type '" "lldb::LanguageType""'");
  } 
  arg1 = static_cast< lldb::LanguageType >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBLanguageRuntime::GetThrowKeywordForLanguage(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLanguageRuntime_GetCatchKeywordForLanguage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::LanguageType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBLanguageRuntime_GetCatchKeywordForLanguage" "', argument " "1"" of type '" "lldb::LanguageType""'");
  } 
  arg1 = static_cast< lldb::LanguageType >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBLanguageRuntime::GetCatchKeywordForLanguage(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBLanguageRuntime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLanguageRuntime *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SBLanguageRuntime", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBLanguageRuntime *)new lldb::SBLanguageRuntime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBLanguageRuntime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBLanguageRuntime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLanguageRuntime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLanguageRuntime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBLanguageRuntime" "', argument " "1"" of type '" "lldb::SBLanguageRuntime *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLanguageRuntime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBLanguageRuntime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBLanguageRuntime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBLanguageRuntime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBLaunchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char **arg1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBLaunchInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    /* Check if is a list  */
    if (PythonList::Check(swig_obj[0])) {
      PythonList list(PyRefType::Borrowed, swig_obj[0]);
      int size = list.GetSize();
      int i = 0;
      arg1 = (char **)malloc((size + 1) * sizeof(char *));
      for (i = 0; i < size; i++) {
        PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
        if (!py_str.IsAllocated()) {
          PyErr_SetString(PyExc_TypeError, "list must contain strings");
          SWIG_fail;
        }
        
        arg1[i] = const_cast<char *>(py_str.GetString().data());
      }
      arg1[i] = 0;
    } else if (swig_obj[0] == Py_None) {
      arg1 = NULL;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBLaunchInfo *)new lldb::SBLaunchInfo((char const **)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBLaunchInfo, SWIG_POINTER_NEW |  0 );
  {
    free((char *) arg1);
  }
  return resultobj;
fail:
  {
    free((char *) arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBLaunchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBLaunchInfo" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetProcessID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::pid_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetProcessID" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::pid_t)(arg1)->GetProcessID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetUserID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetUserID" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetUserID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetGroupID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetGroupID" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetGroupID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_UserIDIsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_UserIDIsValid" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->UserIDIsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GroupIDIsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GroupIDIsValid" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GroupIDIsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetUserID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetUserID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetUserID" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBLaunchInfo_SetUserID" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetUserID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetGroupID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetGroupID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetGroupID" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBLaunchInfo_SetGroupID" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetGroupID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetExecutableFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetExecutableFile" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetExecutableFile();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetExecutableFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  lldb::SBFileSpec arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetExecutableFile", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetExecutableFile" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBLaunchInfo_SetExecutableFile" "', argument " "2"" of type '" "lldb::SBFileSpec""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBLaunchInfo_SetExecutableFile" "', argument " "2"" of type '" "lldb::SBFileSpec""'");
    } else {
      lldb::SBFileSpec * temp = reinterpret_cast< lldb::SBFileSpec * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBLaunchInfo_SetExecutableFile" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetExecutableFile(SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBListener result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetListener" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetListener();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBListener(result)), SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  lldb::SBListener *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetListener", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetListener" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBListener,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBLaunchInfo_SetListener" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBLaunchInfo_SetListener" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBListener * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetListener(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetShadowListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBListener result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetShadowListener" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetShadowListener();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBListener(result)), SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetShadowListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  lldb::SBListener *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetShadowListener", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetShadowListener" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBListener,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBLaunchInfo_SetShadowListener" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBLaunchInfo_SetShadowListener" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBListener * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetShadowListener(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetNumArguments(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetNumArguments" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumArguments();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetArgumentAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_GetArgumentAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetArgumentAtIndex" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBLaunchInfo_GetArgumentAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetArgumentAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetArguments(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  char **arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetArguments", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetArguments" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    /* Check if is a list  */
    if (PythonList::Check(swig_obj[1])) {
      PythonList list(PyRefType::Borrowed, swig_obj[1]);
      int size = list.GetSize();
      int i = 0;
      arg2 = (char **)malloc((size + 1) * sizeof(char *));
      for (i = 0; i < size; i++) {
        PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
        if (!py_str.IsAllocated()) {
          PyErr_SetString(PyExc_TypeError, "list must contain strings");
          SWIG_fail;
        }
        
        arg2[i] = const_cast<char *>(py_str.GetString().data());
      }
      arg2[i] = 0;
    } else if (swig_obj[1] == Py_None) {
      arg2 = NULL;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBLaunchInfo_SetArguments" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetArguments((char const **)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    free((char *) arg2);
  }
  return resultobj;
fail:
  {
    free((char *) arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetNumEnvironmentEntries(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetNumEnvironmentEntries" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumEnvironmentEntries();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetEnvironmentEntryAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_GetEnvironmentEntryAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetEnvironmentEntryAtIndex" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBLaunchInfo_GetEnvironmentEntryAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetEnvironmentEntryAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetEnvironmentEntries(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  char **arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetEnvironmentEntries", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetEnvironmentEntries" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    /* Check if is a list  */
    if (PythonList::Check(swig_obj[1])) {
      PythonList list(PyRefType::Borrowed, swig_obj[1]);
      int size = list.GetSize();
      int i = 0;
      arg2 = (char **)malloc((size + 1) * sizeof(char *));
      for (i = 0; i < size; i++) {
        PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
        if (!py_str.IsAllocated()) {
          PyErr_SetString(PyExc_TypeError, "list must contain strings");
          SWIG_fail;
        }
        
        arg2[i] = const_cast<char *>(py_str.GetString().data());
      }
      arg2[i] = 0;
    } else if (swig_obj[1] == Py_None) {
      arg2 = NULL;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBLaunchInfo_SetEnvironmentEntries" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetEnvironmentEntries((char const **)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    free((char *) arg2);
  }
  return resultobj;
fail:
  {
    free((char *) arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetEnvironment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  lldb::SBEnvironment *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetEnvironment", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetEnvironment" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBEnvironment,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBLaunchInfo_SetEnvironment" "', argument " "2"" of type '" "lldb::SBEnvironment const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBLaunchInfo_SetEnvironment" "', argument " "2"" of type '" "lldb::SBEnvironment const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBEnvironment * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBLaunchInfo_SetEnvironment" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetEnvironment((lldb::SBEnvironment const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetEnvironment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBEnvironment result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetEnvironment" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetEnvironment();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBEnvironment(result)), SWIGTYPE_p_lldb__SBEnvironment, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_Clear" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetWorkingDirectory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetWorkingDirectory" "', argument " "1"" of type '" "lldb::SBLaunchInfo const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBLaunchInfo const *)arg1)->GetWorkingDirectory();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetWorkingDirectory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetWorkingDirectory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetWorkingDirectory" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBLaunchInfo_SetWorkingDirectory" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetWorkingDirectory((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetLaunchFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetLaunchFlags" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetLaunchFlags();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetLaunchFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetLaunchFlags", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetLaunchFlags" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBLaunchInfo_SetLaunchFlags" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetLaunchFlags(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetProcessPluginName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetProcessPluginName" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetProcessPluginName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetProcessPluginName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetProcessPluginName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetProcessPluginName" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBLaunchInfo_SetProcessPluginName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetProcessPluginName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetShell(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetShell" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetShell();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetShell(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetShell", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetShell" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBLaunchInfo_SetShell" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetShell((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetShellExpandArguments(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetShellExpandArguments" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetShellExpandArguments();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetShellExpandArguments(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetShellExpandArguments", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetShellExpandArguments" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBLaunchInfo_SetShellExpandArguments" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetShellExpandArguments(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetResumeCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetResumeCount" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetResumeCount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetResumeCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetResumeCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetResumeCount" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBLaunchInfo_SetResumeCount" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetResumeCount(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_AddCloseFileAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_AddCloseFileAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_AddCloseFileAction" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBLaunchInfo_AddCloseFileAction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->AddCloseFileAction(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_AddDuplicateFileAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_AddDuplicateFileAction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_AddDuplicateFileAction" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBLaunchInfo_AddDuplicateFileAction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBLaunchInfo_AddDuplicateFileAction" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->AddDuplicateFileAction(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_AddOpenFileAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  int arg2 ;
  char *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_AddOpenFileAction", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_AddOpenFileAction" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBLaunchInfo_AddOpenFileAction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBLaunchInfo_AddOpenFileAction" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBLaunchInfo_AddOpenFileAction" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBLaunchInfo_AddOpenFileAction" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->AddOpenFileAction(arg2,(char const *)arg3,arg4,arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_AddSuppressFileAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  int arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_AddSuppressFileAction", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_AddSuppressFileAction" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBLaunchInfo_AddSuppressFileAction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBLaunchInfo_AddSuppressFileAction" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBLaunchInfo_AddSuppressFileAction" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->AddSuppressFileAction(arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetLaunchEventData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetLaunchEventData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetLaunchEventData" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBLaunchInfo_SetLaunchEventData" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetLaunchEventData((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetLaunchEventData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetLaunchEventData" "', argument " "1"" of type '" "lldb::SBLaunchInfo const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBLaunchInfo const *)arg1)->GetLaunchEventData();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetDetachOnError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetDetachOnError" "', argument " "1"" of type '" "lldb::SBLaunchInfo const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBLaunchInfo const *)arg1)->GetDetachOnError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetDetachOnError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetDetachOnError", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetDetachOnError" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBLaunchInfo_SetDetachOnError" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetDetachOnError(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetScriptedProcessClassName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetScriptedProcessClassName" "', argument " "1"" of type '" "lldb::SBLaunchInfo const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBLaunchInfo const *)arg1)->GetScriptedProcessClassName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetScriptedProcessClassName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetScriptedProcessClassName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetScriptedProcessClassName" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBLaunchInfo_SetScriptedProcessClassName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetScriptedProcessClassName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_GetScriptedProcessDictionary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_GetScriptedProcessDictionary" "', argument " "1"" of type '" "lldb::SBLaunchInfo const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBLaunchInfo const *)arg1)->GetScriptedProcessDictionary();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLaunchInfo_SetScriptedProcessDictionary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLaunchInfo *arg1 = 0 ;
  lldb::SBStructuredData arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLaunchInfo_SetScriptedProcessDictionary", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLaunchInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLaunchInfo_SetScriptedProcessDictionary" "', argument " "1"" of type '" "lldb::SBLaunchInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLaunchInfo * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStructuredData,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBLaunchInfo_SetScriptedProcessDictionary" "', argument " "2"" of type '" "lldb::SBStructuredData""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBLaunchInfo_SetScriptedProcessDictionary" "', argument " "2"" of type '" "lldb::SBStructuredData""'");
    } else {
      lldb::SBStructuredData * temp = reinterpret_cast< lldb::SBStructuredData * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetScriptedProcessDictionary(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBLaunchInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBLaunchInfo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBLaunchInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBLineEntry__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBLineEntry *)new lldb::SBLineEntry();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBLineEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBLineEntry__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBLineEntry *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBLineEntry,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBLineEntry" "', argument " "1"" of type '" "lldb::SBLineEntry const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBLineEntry" "', argument " "1"" of type '" "lldb::SBLineEntry const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBLineEntry *)new lldb::SBLineEntry((lldb::SBLineEntry const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBLineEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBLineEntry(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBLineEntry", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBLineEntry__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBLineEntry, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBLineEntry__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBLineEntry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBLineEntry::SBLineEntry()\n"
    "    lldb::SBLineEntry::SBLineEntry(lldb::SBLineEntry const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBLineEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLineEntry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBLineEntry" "', argument " "1"" of type '" "lldb::SBLineEntry *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLineEntry_GetStartAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLineEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLineEntry_GetStartAddress" "', argument " "1"" of type '" "lldb::SBLineEntry const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBLineEntry const *)arg1)->GetStartAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLineEntry_GetEndAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLineEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLineEntry_GetEndAddress" "', argument " "1"" of type '" "lldb::SBLineEntry const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBLineEntry const *)arg1)->GetEndAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLineEntry_GetSameLineContiguousAddressRangeEnd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLineEntry_GetSameLineContiguousAddressRangeEnd", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLineEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLineEntry_GetSameLineContiguousAddressRangeEnd" "', argument " "1"" of type '" "lldb::SBLineEntry const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBLineEntry_GetSameLineContiguousAddressRangeEnd" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBLineEntry const *)arg1)->GetSameLineContiguousAddressRangeEnd(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLineEntry___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLineEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLineEntry___nonzero__" "', argument " "1"" of type '" "lldb::SBLineEntry const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBLineEntry const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLineEntry_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLineEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLineEntry_IsValid" "', argument " "1"" of type '" "lldb::SBLineEntry const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBLineEntry const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLineEntry_GetFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLineEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLineEntry_GetFileSpec" "', argument " "1"" of type '" "lldb::SBLineEntry const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBLineEntry const *)arg1)->GetFileSpec();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLineEntry_GetLine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLineEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLineEntry_GetLine" "', argument " "1"" of type '" "lldb::SBLineEntry const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBLineEntry const *)arg1)->GetLine();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLineEntry_GetColumn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLineEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLineEntry_GetColumn" "', argument " "1"" of type '" "lldb::SBLineEntry const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBLineEntry const *)arg1)->GetColumn();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLineEntry_SetFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  lldb::SBFileSpec arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLineEntry_SetFileSpec", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLineEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLineEntry_SetFileSpec" "', argument " "1"" of type '" "lldb::SBLineEntry *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBLineEntry_SetFileSpec" "', argument " "2"" of type '" "lldb::SBFileSpec""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBLineEntry_SetFileSpec" "', argument " "2"" of type '" "lldb::SBFileSpec""'");
    } else {
      lldb::SBFileSpec * temp = reinterpret_cast< lldb::SBFileSpec * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetFileSpec(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLineEntry_SetLine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLineEntry_SetLine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLineEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLineEntry_SetLine" "', argument " "1"" of type '" "lldb::SBLineEntry *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBLineEntry_SetLine" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetLine(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLineEntry_SetColumn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLineEntry_SetColumn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLineEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLineEntry_SetColumn" "', argument " "1"" of type '" "lldb::SBLineEntry *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBLineEntry_SetColumn" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetColumn(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLineEntry___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  lldb::SBLineEntry *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLineEntry___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLineEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLineEntry___eq__" "', argument " "1"" of type '" "lldb::SBLineEntry const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBLineEntry,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBLineEntry___eq__" "', argument " "2"" of type '" "lldb::SBLineEntry const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBLineEntry___eq__" "', argument " "2"" of type '" "lldb::SBLineEntry const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBLineEntry * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBLineEntry const *)arg1)->operator ==((lldb::SBLineEntry const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBLineEntry___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  lldb::SBLineEntry *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLineEntry___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLineEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLineEntry___ne__" "', argument " "1"" of type '" "lldb::SBLineEntry const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBLineEntry,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBLineEntry___ne__" "', argument " "2"" of type '" "lldb::SBLineEntry const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBLineEntry___ne__" "', argument " "2"" of type '" "lldb::SBLineEntry const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBLineEntry * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBLineEntry const *)arg1)->operator !=((lldb::SBLineEntry const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBLineEntry_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBLineEntry_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLineEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLineEntry_GetDescription" "', argument " "1"" of type '" "lldb::SBLineEntry *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBLineEntry_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBLineEntry_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBLineEntry___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBLineEntry *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBLineEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBLineEntry___repr__" "', argument " "1"" of type '" "lldb::SBLineEntry *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBLineEntry * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBLineEntry___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBLineEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBLineEntry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBLineEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBListener__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBListener *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBListener *)new lldb::SBListener();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBListener__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  lldb::SBListener *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBListener" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBListener *)new lldb::SBListener((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBListener__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBListener *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBListener,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBListener" "', argument " "1"" of type '" "lldb::SBListener const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBListener" "', argument " "1"" of type '" "lldb::SBListener const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBListener *)new lldb::SBListener((lldb::SBListener const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBListener(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBListener", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBListener__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBListener__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBListener__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBListener'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBListener::SBListener()\n"
    "    lldb::SBListener::SBListener(char const *)\n"
    "    lldb::SBListener::SBListener(lldb::SBListener const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBListener" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_AddEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  lldb::SBEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBListener_AddEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_AddEvent" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBListener_AddEvent" "', argument " "2"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_AddEvent" "', argument " "2"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBEvent * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->AddEvent((lldb::SBEvent const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_Clear" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener___nonzero__" "', argument " "1"" of type '" "lldb::SBListener const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBListener const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_IsValid" "', argument " "1"" of type '" "lldb::SBListener const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBListener const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_StartListeningForEventClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  lldb::SBDebugger *arg2 = 0 ;
  char *arg3 = 0 ;
  uint32_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBListener_StartListeningForEventClass", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_StartListeningForEventClass" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBDebugger,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBListener_StartListeningForEventClass" "', argument " "2"" of type '" "lldb::SBDebugger &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_StartListeningForEventClass" "', argument " "2"" of type '" "lldb::SBDebugger &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBDebugger * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBListener_StartListeningForEventClass" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBListener_StartListeningForEventClass" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->StartListeningForEventClass(*arg2,(char const *)arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_StopListeningForEventClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  lldb::SBDebugger *arg2 = 0 ;
  char *arg3 = 0 ;
  uint32_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBListener_StopListeningForEventClass", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_StopListeningForEventClass" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBDebugger,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBListener_StopListeningForEventClass" "', argument " "2"" of type '" "lldb::SBDebugger &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_StopListeningForEventClass" "', argument " "2"" of type '" "lldb::SBDebugger &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBDebugger * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBListener_StopListeningForEventClass" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBListener_StopListeningForEventClass" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->StopListeningForEventClass(*arg2,(char const *)arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_StartListeningForEvents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  lldb::SBBroadcaster *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBListener_StartListeningForEvents", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_StartListeningForEvents" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBroadcaster,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBListener_StartListeningForEvents" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_StartListeningForEvents" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBBroadcaster * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBListener_StartListeningForEvents" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->StartListeningForEvents((lldb::SBBroadcaster const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_StopListeningForEvents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  lldb::SBBroadcaster *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBListener_StopListeningForEvents", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_StopListeningForEvents" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBroadcaster,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBListener_StopListeningForEvents" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_StopListeningForEvents" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBBroadcaster * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBListener_StopListeningForEvents" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->StopListeningForEvents((lldb::SBBroadcaster const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_WaitForEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  uint32_t arg2 ;
  lldb::SBEvent *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBListener_WaitForEvent", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_WaitForEvent" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBListener_WaitForEvent" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBEvent,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBListener_WaitForEvent" "', argument " "3"" of type '" "lldb::SBEvent &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_WaitForEvent" "', argument " "3"" of type '" "lldb::SBEvent &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBEvent * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->WaitForEvent(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_WaitForEventForBroadcaster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  uint32_t arg2 ;
  lldb::SBBroadcaster *arg3 = 0 ;
  lldb::SBEvent *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBListener_WaitForEventForBroadcaster", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_WaitForEventForBroadcaster" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBListener_WaitForEventForBroadcaster" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBBroadcaster,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBListener_WaitForEventForBroadcaster" "', argument " "3"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_WaitForEventForBroadcaster" "', argument " "3"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBBroadcaster * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBEvent,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBListener_WaitForEventForBroadcaster" "', argument " "4"" of type '" "lldb::SBEvent &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_WaitForEventForBroadcaster" "', argument " "4"" of type '" "lldb::SBEvent &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBEvent * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->WaitForEventForBroadcaster(arg2,(lldb::SBBroadcaster const &)*arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_WaitForEventForBroadcasterWithType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  uint32_t arg2 ;
  lldb::SBBroadcaster *arg3 = 0 ;
  uint32_t arg4 ;
  lldb::SBEvent *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBListener_WaitForEventForBroadcasterWithType", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_WaitForEventForBroadcasterWithType" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBListener_WaitForEventForBroadcasterWithType" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBBroadcaster,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBListener_WaitForEventForBroadcasterWithType" "', argument " "3"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_WaitForEventForBroadcasterWithType" "', argument " "3"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBBroadcaster * >(argp3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBListener_WaitForEventForBroadcasterWithType" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBEvent,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBListener_WaitForEventForBroadcasterWithType" "', argument " "5"" of type '" "lldb::SBEvent &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_WaitForEventForBroadcasterWithType" "', argument " "5"" of type '" "lldb::SBEvent &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBEvent * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->WaitForEventForBroadcasterWithType(arg2,(lldb::SBBroadcaster const &)*arg3,arg4,*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_PeekAtNextEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  lldb::SBEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBListener_PeekAtNextEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_PeekAtNextEvent" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBListener_PeekAtNextEvent" "', argument " "2"" of type '" "lldb::SBEvent &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_PeekAtNextEvent" "', argument " "2"" of type '" "lldb::SBEvent &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBEvent * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->PeekAtNextEvent(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_PeekAtNextEventForBroadcaster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  lldb::SBBroadcaster *arg2 = 0 ;
  lldb::SBEvent *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBListener_PeekAtNextEventForBroadcaster", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_PeekAtNextEventForBroadcaster" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBroadcaster,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBListener_PeekAtNextEventForBroadcaster" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_PeekAtNextEventForBroadcaster" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBBroadcaster * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBEvent,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBListener_PeekAtNextEventForBroadcaster" "', argument " "3"" of type '" "lldb::SBEvent &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_PeekAtNextEventForBroadcaster" "', argument " "3"" of type '" "lldb::SBEvent &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBEvent * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->PeekAtNextEventForBroadcaster((lldb::SBBroadcaster const &)*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_PeekAtNextEventForBroadcasterWithType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  lldb::SBBroadcaster *arg2 = 0 ;
  uint32_t arg3 ;
  lldb::SBEvent *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBListener_PeekAtNextEventForBroadcasterWithType", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_PeekAtNextEventForBroadcasterWithType" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBroadcaster,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBListener_PeekAtNextEventForBroadcasterWithType" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_PeekAtNextEventForBroadcasterWithType" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBBroadcaster * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBListener_PeekAtNextEventForBroadcasterWithType" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBEvent,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBListener_PeekAtNextEventForBroadcasterWithType" "', argument " "4"" of type '" "lldb::SBEvent &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_PeekAtNextEventForBroadcasterWithType" "', argument " "4"" of type '" "lldb::SBEvent &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBEvent * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->PeekAtNextEventForBroadcasterWithType((lldb::SBBroadcaster const &)*arg2,arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_GetNextEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  lldb::SBEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBListener_GetNextEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_GetNextEvent" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBListener_GetNextEvent" "', argument " "2"" of type '" "lldb::SBEvent &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_GetNextEvent" "', argument " "2"" of type '" "lldb::SBEvent &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBEvent * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetNextEvent(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_GetNextEventForBroadcaster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  lldb::SBBroadcaster *arg2 = 0 ;
  lldb::SBEvent *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBListener_GetNextEventForBroadcaster", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_GetNextEventForBroadcaster" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBroadcaster,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBListener_GetNextEventForBroadcaster" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_GetNextEventForBroadcaster" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBBroadcaster * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBEvent,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBListener_GetNextEventForBroadcaster" "', argument " "3"" of type '" "lldb::SBEvent &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_GetNextEventForBroadcaster" "', argument " "3"" of type '" "lldb::SBEvent &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBEvent * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetNextEventForBroadcaster((lldb::SBBroadcaster const &)*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_GetNextEventForBroadcasterWithType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  lldb::SBBroadcaster *arg2 = 0 ;
  uint32_t arg3 ;
  lldb::SBEvent *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBListener_GetNextEventForBroadcasterWithType", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_GetNextEventForBroadcasterWithType" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBroadcaster,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBListener_GetNextEventForBroadcasterWithType" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_GetNextEventForBroadcasterWithType" "', argument " "2"" of type '" "lldb::SBBroadcaster const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBBroadcaster * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBListener_GetNextEventForBroadcasterWithType" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBEvent,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBListener_GetNextEventForBroadcasterWithType" "', argument " "4"" of type '" "lldb::SBEvent &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_GetNextEventForBroadcasterWithType" "', argument " "4"" of type '" "lldb::SBEvent &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBEvent * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetNextEventForBroadcasterWithType((lldb::SBBroadcaster const &)*arg2,arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBListener_HandleBroadcastEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBListener *arg1 = 0 ;
  lldb::SBEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBListener_HandleBroadcastEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBListener_HandleBroadcastEvent" "', argument " "1"" of type '" "lldb::SBListener *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBListener_HandleBroadcastEvent" "', argument " "2"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBListener_HandleBroadcastEvent" "', argument " "2"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBEvent * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->HandleBroadcastEvent((lldb::SBEvent const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBListener_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBListener, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBListener_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBMemoryRegionInfo__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBMemoryRegionInfo *)new lldb::SBMemoryRegionInfo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBMemoryRegionInfo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMemoryRegionInfo__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBMemoryRegionInfo *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBMemoryRegionInfo,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMemoryRegionInfo" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBMemoryRegionInfo" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBMemoryRegionInfo *)new lldb::SBMemoryRegionInfo((lldb::SBMemoryRegionInfo const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBMemoryRegionInfo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMemoryRegionInfo__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  lldb::addr_t arg2 ;
  lldb::addr_t arg3 ;
  uint32_t arg4 ;
  bool arg5 ;
  bool arg6 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  lldb::SBMemoryRegionInfo *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMemoryRegionInfo" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBMemoryRegionInfo" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SBMemoryRegionInfo" "', argument " "3"" of type '" "lldb::addr_t""'");
  } 
  arg3 = static_cast< lldb::addr_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SBMemoryRegionInfo" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SBMemoryRegionInfo" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SBMemoryRegionInfo" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBMemoryRegionInfo *)new lldb::SBMemoryRegionInfo((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBMemoryRegionInfo, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMemoryRegionInfo__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  lldb::addr_t arg2 ;
  lldb::addr_t arg3 ;
  uint32_t arg4 ;
  bool arg5 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  lldb::SBMemoryRegionInfo *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMemoryRegionInfo" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBMemoryRegionInfo" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SBMemoryRegionInfo" "', argument " "3"" of type '" "lldb::addr_t""'");
  } 
  arg3 = static_cast< lldb::addr_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SBMemoryRegionInfo" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SBMemoryRegionInfo" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBMemoryRegionInfo *)new lldb::SBMemoryRegionInfo((char const *)arg1,arg2,arg3,arg4,arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBMemoryRegionInfo, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMemoryRegionInfo(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMemoryRegionInfo", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMemoryRegionInfo__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBMemoryRegionInfo, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMemoryRegionInfo__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_SBMemoryRegionInfo__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_SBMemoryRegionInfo__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMemoryRegionInfo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBMemoryRegionInfo::SBMemoryRegionInfo()\n"
    "    lldb::SBMemoryRegionInfo::SBMemoryRegionInfo(lldb::SBMemoryRegionInfo const &)\n"
    "    lldb::SBMemoryRegionInfo::SBMemoryRegionInfo(char const *,lldb::addr_t,lldb::addr_t,uint32_t,bool,bool)\n"
    "    lldb::SBMemoryRegionInfo::SBMemoryRegionInfo(char const *,lldb::addr_t,lldb::addr_t,uint32_t,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBMemoryRegionInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMemoryRegionInfo" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfo_Clear" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetRegionBase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfo_GetRegionBase" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->GetRegionBase();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetRegionEnd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfo_GetRegionEnd" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->GetRegionEnd();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_IsReadable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfo_IsReadable" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsReadable();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_IsWritable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfo_IsWritable" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsWritable();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_IsExecutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfo_IsExecutable" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsExecutable();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_IsMapped(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfo_IsMapped" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsMapped();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfo_GetName" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_HasDirtyMemoryPageList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfo_HasDirtyMemoryPageList" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->HasDirtyMemoryPageList();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetNumDirtyPages(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfo_GetNumDirtyPages" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumDirtyPages();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetDirtyPageAddressAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::addr_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBMemoryRegionInfo_GetDirtyPageAddressAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfo_GetDirtyPageAddressAtIndex" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMemoryRegionInfo_GetDirtyPageAddressAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->GetDirtyPageAddressAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetPageSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfo_GetPageSize" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)(arg1)->GetPageSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  lldb::SBMemoryRegionInfo *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBMemoryRegionInfo___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfo___eq__" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBMemoryRegionInfo,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMemoryRegionInfo___eq__" "', argument " "2"" of type '" "lldb::SBMemoryRegionInfo const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBMemoryRegionInfo___eq__" "', argument " "2"" of type '" "lldb::SBMemoryRegionInfo const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBMemoryRegionInfo const *)arg1)->operator ==((lldb::SBMemoryRegionInfo const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  lldb::SBMemoryRegionInfo *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBMemoryRegionInfo___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfo___ne__" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBMemoryRegionInfo,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMemoryRegionInfo___ne__" "', argument " "2"" of type '" "lldb::SBMemoryRegionInfo const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBMemoryRegionInfo___ne__" "', argument " "2"" of type '" "lldb::SBMemoryRegionInfo const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBMemoryRegionInfo const *)arg1)->operator !=((lldb::SBMemoryRegionInfo const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBMemoryRegionInfo_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfo_GetDescription" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMemoryRegionInfo_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBMemoryRegionInfo_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfo___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfo___repr__" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBMemoryRegionInfo___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMemoryRegionInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBMemoryRegionInfo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMemoryRegionInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBMemoryRegionInfoList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfoList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBMemoryRegionInfoList *)new lldb::SBMemoryRegionInfoList();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBMemoryRegionInfoList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMemoryRegionInfoList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfoList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBMemoryRegionInfoList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBMemoryRegionInfoList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMemoryRegionInfoList" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfoList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBMemoryRegionInfoList" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfoList const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfoList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBMemoryRegionInfoList *)new lldb::SBMemoryRegionInfoList((lldb::SBMemoryRegionInfoList const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBMemoryRegionInfoList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMemoryRegionInfoList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMemoryRegionInfoList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMemoryRegionInfoList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBMemoryRegionInfoList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMemoryRegionInfoList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMemoryRegionInfoList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBMemoryRegionInfoList::SBMemoryRegionInfoList()\n"
    "    lldb::SBMemoryRegionInfoList::SBMemoryRegionInfoList(lldb::SBMemoryRegionInfoList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBMemoryRegionInfoList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfoList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMemoryRegionInfoList" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfoList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfoList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfoList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfoList_GetSize" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfoList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfoList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBMemoryRegionInfoList const *)arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_GetMemoryRegionContainingAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfoList *arg1 = 0 ;
  lldb::addr_t arg2 ;
  lldb::SBMemoryRegionInfo *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBMemoryRegionInfoList_GetMemoryRegionContainingAddress", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfoList_GetMemoryRegionContainingAddress" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfoList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfoList * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMemoryRegionInfoList_GetMemoryRegionContainingAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBMemoryRegionInfo,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBMemoryRegionInfoList_GetMemoryRegionContainingAddress" "', argument " "3"" of type '" "lldb::SBMemoryRegionInfo &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBMemoryRegionInfoList_GetMemoryRegionContainingAddress" "', argument " "3"" of type '" "lldb::SBMemoryRegionInfo &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetMemoryRegionContainingAddress(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_GetMemoryRegionAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfoList *arg1 = 0 ;
  uint32_t arg2 ;
  lldb::SBMemoryRegionInfo *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBMemoryRegionInfoList_GetMemoryRegionAtIndex", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfoList_GetMemoryRegionAtIndex" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfoList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfoList * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMemoryRegionInfoList_GetMemoryRegionAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBMemoryRegionInfo,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBMemoryRegionInfoList_GetMemoryRegionAtIndex" "', argument " "3"" of type '" "lldb::SBMemoryRegionInfo &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBMemoryRegionInfoList_GetMemoryRegionAtIndex" "', argument " "3"" of type '" "lldb::SBMemoryRegionInfo &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetMemoryRegionAtIndex(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_Append__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfoList *arg1 = 0 ;
  lldb::SBMemoryRegionInfo *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfoList_Append" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfoList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfoList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBMemoryRegionInfo,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMemoryRegionInfoList_Append" "', argument " "2"" of type '" "lldb::SBMemoryRegionInfo &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBMemoryRegionInfoList_Append" "', argument " "2"" of type '" "lldb::SBMemoryRegionInfo &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Append(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_Append__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfoList *arg1 = 0 ;
  lldb::SBMemoryRegionInfoList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfoList_Append" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfoList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfoList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBMemoryRegionInfoList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMemoryRegionInfoList_Append" "', argument " "2"" of type '" "lldb::SBMemoryRegionInfoList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBMemoryRegionInfoList_Append" "', argument " "2"" of type '" "lldb::SBMemoryRegionInfoList &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBMemoryRegionInfoList * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Append(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_Append(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMemoryRegionInfoList_Append", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBMemoryRegionInfoList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBMemoryRegionInfo, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBMemoryRegionInfoList_Append__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBMemoryRegionInfoList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBMemoryRegionInfoList, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBMemoryRegionInfoList_Append__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMemoryRegionInfoList_Append'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBMemoryRegionInfoList::Append(lldb::SBMemoryRegionInfo &)\n"
    "    lldb::SBMemoryRegionInfoList::Append(lldb::SBMemoryRegionInfoList &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMemoryRegionInfoList_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMemoryRegionInfoList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMemoryRegionInfoList_Clear" "', argument " "1"" of type '" "lldb::SBMemoryRegionInfoList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMemoryRegionInfoList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMemoryRegionInfoList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBMemoryRegionInfoList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMemoryRegionInfoList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBModule__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBModule *)new lldb::SBModule();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBModule__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBModule,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBModule" "', argument " "1"" of type '" "lldb::SBModule const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBModule" "', argument " "1"" of type '" "lldb::SBModule const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBModule *)new lldb::SBModule((lldb::SBModule const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBModule__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBModuleSpec,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBModule" "', argument " "1"" of type '" "lldb::SBModuleSpec const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBModule" "', argument " "1"" of type '" "lldb::SBModuleSpec const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBModule *)new lldb::SBModule((lldb::SBModuleSpec const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBModule__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::addr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  lldb::SBModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBProcess,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBModule" "', argument " "1"" of type '" "lldb::SBProcess &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBModule" "', argument " "1"" of type '" "lldb::SBProcess &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBModule" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBModule *)new lldb::SBModule(*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBModule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBModule", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBModule__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBModule__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBModule__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SBModule__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBModule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBModule::SBModule()\n"
    "    lldb::SBModule::SBModule(lldb::SBModule const &)\n"
    "    lldb::SBModule::SBModule(lldb::SBModuleSpec const &)\n"
    "    lldb::SBModule::SBModule(lldb::SBProcess &,lldb::addr_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBModule" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule___nonzero__" "', argument " "1"" of type '" "lldb::SBModule const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBModule const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_IsValid" "', argument " "1"" of type '" "lldb::SBModule const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBModule const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_Clear" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_IsFileBacked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_IsFileBacked" "', argument " "1"" of type '" "lldb::SBModule const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBModule const *)arg1)->IsFileBacked();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetFileSpec" "', argument " "1"" of type '" "lldb::SBModule const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBModule const *)arg1)->GetFileSpec();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetPlatformFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetPlatformFileSpec" "', argument " "1"" of type '" "lldb::SBModule const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBModule const *)arg1)->GetPlatformFileSpec();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_SetPlatformFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_SetPlatformFileSpec", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_SetPlatformFileSpec" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule_SetPlatformFileSpec" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModule_SetPlatformFileSpec" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetPlatformFileSpec((lldb::SBFileSpec const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetRemoteInstallFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetRemoteInstallFileSpec" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetRemoteInstallFileSpec();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_SetRemoteInstallFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_SetRemoteInstallFileSpec", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_SetRemoteInstallFileSpec" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule_SetRemoteInstallFileSpec" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModule_SetRemoteInstallFileSpec" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetRemoteInstallFileSpec(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetByteOrder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::ByteOrder result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetByteOrder" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ByteOrder)(arg1)->GetByteOrder();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetAddressByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetAddressByteSize" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetAddressByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetTriple(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetTriple" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetTriple();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetUUIDBytes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint8_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetUUIDBytes" "', argument " "1"" of type '" "lldb::SBModule const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint8_t *)((lldb::SBModule const *)arg1)->GetUUIDBytes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetUUIDString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetUUIDString" "', argument " "1"" of type '" "lldb::SBModule const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBModule const *)arg1)->GetUUIDString();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  lldb::SBModule *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule___eq__" "', argument " "1"" of type '" "lldb::SBModule const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBModule,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule___eq__" "', argument " "2"" of type '" "lldb::SBModule const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModule___eq__" "', argument " "2"" of type '" "lldb::SBModule const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBModule * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBModule const *)arg1)->operator ==((lldb::SBModule const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBModule___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  lldb::SBModule *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule___ne__" "', argument " "1"" of type '" "lldb::SBModule const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBModule,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule___ne__" "', argument " "2"" of type '" "lldb::SBModule const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModule___ne__" "', argument " "2"" of type '" "lldb::SBModule const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBModule * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBModule const *)arg1)->operator !=((lldb::SBModule const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBModule_FindSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBSection result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_FindSection", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_FindSection" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule_FindSection" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindSection((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSection(result)), SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_ResolveFileAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  lldb::addr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_ResolveFileAddress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_ResolveFileAddress" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBModule_ResolveFileAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ResolveFileAddress(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_ResolveSymbolContextForAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  lldb::SBAddress *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBSymbolContext result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_ResolveSymbolContextForAddress", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_ResolveSymbolContextForAddress" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule_ResolveSymbolContextForAddress" "', argument " "2"" of type '" "lldb::SBAddress const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModule_ResolveSymbolContextForAddress" "', argument " "2"" of type '" "lldb::SBAddress const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAddress * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBModule_ResolveSymbolContextForAddress" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ResolveSymbolContextForAddress((lldb::SBAddress const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContext(result)), SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetDescription" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModule_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetNumCompileUnits(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetNumCompileUnits" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumCompileUnits();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetCompileUnitAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBCompileUnit result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_GetCompileUnitAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetCompileUnitAtIndex" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBModule_GetCompileUnitAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetCompileUnitAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBCompileUnit(result)), SWIGTYPE_p_lldb__SBCompileUnit, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_FindCompileUnits(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBSymbolContextList result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_FindCompileUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_FindCompileUnits" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule_FindCompileUnits" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModule_FindCompileUnits" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindCompileUnits((lldb::SBFileSpec const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContextList(result)), SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetNumSymbols(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetNumSymbols" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetNumSymbols();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetSymbolAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBSymbol result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_GetSymbolAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetSymbolAtIndex" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBModule_GetSymbolAtIndex" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSymbolAtIndex(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbol(result)), SWIGTYPE_p_lldb__SBSymbol, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_FindSymbol__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SymbolType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  lldb::SBSymbol result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_FindSymbol" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule_FindSymbol" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBModule_FindSymbol" "', argument " "3"" of type '" "lldb::SymbolType""'");
  } 
  arg3 = static_cast< lldb::SymbolType >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindSymbol((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbol(result)), SWIGTYPE_p_lldb__SBSymbol, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_FindSymbol__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBSymbol result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_FindSymbol" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule_FindSymbol" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindSymbol((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbol(result)), SWIGTYPE_p_lldb__SBSymbol, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_FindSymbol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBModule_FindSymbol", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBModule_FindSymbol__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBModule_FindSymbol__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBModule_FindSymbol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBModule::FindSymbol(char const *,lldb::SymbolType)\n"
    "    lldb::SBModule::FindSymbol(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBModule_FindSymbols__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SymbolType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  lldb::SBSymbolContextList result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_FindSymbols" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule_FindSymbols" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBModule_FindSymbols" "', argument " "3"" of type '" "lldb::SymbolType""'");
  } 
  arg3 = static_cast< lldb::SymbolType >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindSymbols((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContextList(result)), SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_FindSymbols__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBSymbolContextList result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_FindSymbols" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule_FindSymbols" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindSymbols((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContextList(result)), SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_FindSymbols(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBModule_FindSymbols", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBModule_FindSymbols__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBModule_FindSymbols__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBModule_FindSymbols'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBModule::FindSymbols(char const *,lldb::SymbolType)\n"
    "    lldb::SBModule::FindSymbols(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBModule_GetNumSections(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetNumSections" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetNumSections();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetSectionAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBSection result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_GetSectionAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetSectionAtIndex" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBModule_GetSectionAtIndex" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSectionAtIndex(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSection(result)), SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_FindFunctions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  lldb::SBSymbolContextList result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_FindFunctions" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule_FindFunctions" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBModule_FindFunctions" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindFunctions((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContextList(result)), SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_FindFunctions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBSymbolContextList result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_FindFunctions" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule_FindFunctions" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindFunctions((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContextList(result)), SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_FindFunctions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBModule_FindFunctions", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBModule_FindFunctions__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBModule_FindFunctions__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBModule_FindFunctions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBModule::FindFunctions(char const *,uint32_t)\n"
    "    lldb::SBModule::FindFunctions(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBModule_FindGlobalVariables(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  lldb::SBTarget *arg2 = 0 ;
  char *arg3 = 0 ;
  uint32_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  lldb::SBValueList result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_FindGlobalVariables", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_FindGlobalVariables" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule_FindGlobalVariables" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModule_FindGlobalVariables" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBModule_FindGlobalVariables" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBModule_FindGlobalVariables" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindGlobalVariables(*arg2,(char const *)arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValueList(result)), SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_OWN |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_FindFirstGlobalVariable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  lldb::SBTarget *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_FindFirstGlobalVariable", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_FindFirstGlobalVariable" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule_FindFirstGlobalVariable" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModule_FindFirstGlobalVariable" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBModule_FindFirstGlobalVariable" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindFirstGlobalVariable(*arg2,(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_FindFirstType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_FindFirstType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_FindFirstType" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule_FindFirstType" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindFirstType((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_FindTypes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeList result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_FindTypes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_FindTypes" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModule_FindTypes" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindTypes((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeList(result)), SWIGTYPE_p_lldb__SBTypeList, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetTypeByID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  lldb::user_id_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_GetTypeByID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetTypeByID" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBModule_GetTypeByID" "', argument " "2"" of type '" "lldb::user_id_t""'");
  } 
  arg2 = static_cast< lldb::user_id_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTypeByID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetBasicType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  lldb::BasicType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_GetBasicType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetBasicType" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBModule_GetBasicType" "', argument " "2"" of type '" "lldb::BasicType""'");
  } 
  arg2 = static_cast< lldb::BasicType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetBasicType(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetTypes__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  lldb::SBTypeList result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetTypes" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBModule_GetTypes" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTypes(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeList(result)), SWIGTYPE_p_lldb__SBTypeList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetTypes__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBTypeList result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetTypes" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTypes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeList(result)), SWIGTYPE_p_lldb__SBTypeList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetTypes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBModule_GetTypes", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBModule_GetTypes__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBModule_GetTypes__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBModule_GetTypes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBModule::GetTypes(uint32_t)\n"
    "    lldb::SBModule::GetTypes()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBModule_GetVersion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  uint32_t *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  {
    arg2 = (uint32_t *)malloc(sizeof(uint32_t) * 50);
  }
  {
    arg3 = 50;
  }
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetVersion" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetVersion(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  {
    uint32_t count = result;
    if (count >= arg3)
    count = arg3;
    PyObject *list = PyList_New(count);
    for (uint32_t j = 0; j < count; j++) {
      PyObject *item = PyLong_FromLong(arg2[j]);
      int ok = PyList_SetItem(list, j, item);
      if (ok != 0) {
        resultobj = Py_None;
        break;
      }
    }
    resultobj = list;
  }
  {
    free(arg2);
  }
  return resultobj;
fail:
  {
    free(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetSymbolFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetSymbolFileSpec" "', argument " "1"" of type '" "lldb::SBModule const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBModule const *)arg1)->GetSymbolFileSpec();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetObjectFileHeaderAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetObjectFileHeaderAddress" "', argument " "1"" of type '" "lldb::SBModule const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBModule const *)arg1)->GetObjectFileHeaderAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetObjectFileEntryPointAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetObjectFileEntryPointAddress" "', argument " "1"" of type '" "lldb::SBModule const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBModule const *)arg1)->GetObjectFileEntryPointAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetNumberAllocatedModules(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_GetNumberAllocatedModules", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)lldb::SBModule::GetNumberAllocatedModules();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GarbageCollectAllocatedModules(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModule_GarbageCollectAllocatedModules", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb::SBModule::GarbageCollectAllocatedModules();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule_GetObjectName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule_GetObjectName" "', argument " "1"" of type '" "lldb::SBModule const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBModule const *)arg1)->GetObjectName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModule___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModule___repr__" "', argument " "1"" of type '" "lldb::SBModule *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBModule___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBModule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBModule, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBModule_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBModuleSpec__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBModuleSpec *)new lldb::SBModuleSpec();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBModuleSpec__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBModuleSpec *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBModuleSpec,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBModuleSpec" "', argument " "1"" of type '" "lldb::SBModuleSpec const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBModuleSpec" "', argument " "1"" of type '" "lldb::SBModuleSpec const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBModuleSpec *)new lldb::SBModuleSpec((lldb::SBModuleSpec const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBModuleSpec(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBModuleSpec", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBModuleSpec__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBModuleSpec__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBModuleSpec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBModuleSpec::SBModuleSpec()\n"
    "    lldb::SBModuleSpec::SBModuleSpec(lldb::SBModuleSpec const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBModuleSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBModuleSpec" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec___nonzero__" "', argument " "1"" of type '" "lldb::SBModuleSpec const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBModuleSpec const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_IsValid" "', argument " "1"" of type '" "lldb::SBModuleSpec const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBModuleSpec const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_Clear" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_GetFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_GetFileSpec" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetFileSpec();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_SetFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModuleSpec_SetFileSpec", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_SetFileSpec" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModuleSpec_SetFileSpec" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModuleSpec_SetFileSpec" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetFileSpec((lldb::SBFileSpec const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_GetPlatformFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_GetPlatformFileSpec" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetPlatformFileSpec();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_SetPlatformFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModuleSpec_SetPlatformFileSpec", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_SetPlatformFileSpec" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModuleSpec_SetPlatformFileSpec" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModuleSpec_SetPlatformFileSpec" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetPlatformFileSpec((lldb::SBFileSpec const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_GetSymbolFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_GetSymbolFileSpec" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSymbolFileSpec();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_SetSymbolFileSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModuleSpec_SetSymbolFileSpec", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_SetSymbolFileSpec" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModuleSpec_SetSymbolFileSpec" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModuleSpec_SetSymbolFileSpec" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetSymbolFileSpec((lldb::SBFileSpec const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_GetObjectName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_GetObjectName" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetObjectName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_SetObjectName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModuleSpec_SetObjectName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_SetObjectName" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModuleSpec_SetObjectName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetObjectName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_GetTriple(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_GetTriple" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetTriple();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_SetTriple(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModuleSpec_SetTriple", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_SetTriple" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModuleSpec_SetTriple" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetTriple((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_GetUUIDBytes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint8_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_GetUUIDBytes" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint8_t *)(arg1)->GetUUIDBytes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_GetUUIDLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_GetUUIDLength" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetUUIDLength();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_SetUUIDBytes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  uint8_t *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModuleSpec_SetUUIDBytes", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_SetUUIDBytes" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModuleSpec_SetUUIDBytes" "', argument " "2"" of type '" "uint8_t const *""'"); 
  }
  arg2 = reinterpret_cast< uint8_t * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBModuleSpec_SetUUIDBytes" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetUUIDBytes((uint8_t const *)arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_GetObjectOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_GetObjectOffset" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetObjectOffset();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_SetObjectOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModuleSpec_SetObjectOffset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_SetObjectOffset" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBModuleSpec_SetObjectOffset" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetObjectOffset(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_GetObjectSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_GetObjectSize" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetObjectSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_SetObjectSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModuleSpec_SetObjectSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_SetObjectSize" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBModuleSpec_SetObjectSize" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetObjectSize(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModuleSpec_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_GetDescription" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModuleSpec_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModuleSpec_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_GetTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTarget result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_GetTarget" "', argument " "1"" of type '" "lldb::SBModuleSpec const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBModuleSpec const *)arg1)->GetTarget();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec_SetTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  lldb::SBTarget arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModuleSpec_SetTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec_SetTarget" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModuleSpec_SetTarget" "', argument " "2"" of type '" "lldb::SBTarget""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModuleSpec_SetTarget" "', argument " "2"" of type '" "lldb::SBTarget""'");
    } else {
      lldb::SBTarget * temp = reinterpret_cast< lldb::SBTarget * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetTarget(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpec___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpec___repr__" "', argument " "1"" of type '" "lldb::SBModuleSpec *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpec * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBModuleSpec___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBModuleSpec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBModuleSpec, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBModuleSpec_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBModuleSpecList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpecList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBModuleSpecList *)new lldb::SBModuleSpecList();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBModuleSpecList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBModuleSpecList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpecList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBModuleSpecList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBModuleSpecList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBModuleSpecList" "', argument " "1"" of type '" "lldb::SBModuleSpecList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBModuleSpecList" "', argument " "1"" of type '" "lldb::SBModuleSpecList const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpecList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBModuleSpecList *)new lldb::SBModuleSpecList((lldb::SBModuleSpecList const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBModuleSpecList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBModuleSpecList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBModuleSpecList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBModuleSpecList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBModuleSpecList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBModuleSpecList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBModuleSpecList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBModuleSpecList::SBModuleSpecList()\n"
    "    lldb::SBModuleSpecList::SBModuleSpecList(lldb::SBModuleSpecList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBModuleSpecList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpecList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpecList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBModuleSpecList" "', argument " "1"" of type '" "lldb::SBModuleSpecList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpecList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpecList_GetModuleSpecifications(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBModuleSpecList result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpecList_GetModuleSpecifications" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBModuleSpecList::GetModuleSpecifications((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBModuleSpecList(result)), SWIGTYPE_p_lldb__SBModuleSpecList, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpecList_Append__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpecList *arg1 = 0 ;
  lldb::SBModuleSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpecList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpecList_Append" "', argument " "1"" of type '" "lldb::SBModuleSpecList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpecList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBModuleSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModuleSpecList_Append" "', argument " "2"" of type '" "lldb::SBModuleSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModuleSpecList_Append" "', argument " "2"" of type '" "lldb::SBModuleSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBModuleSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Append((lldb::SBModuleSpec const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpecList_Append__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpecList *arg1 = 0 ;
  lldb::SBModuleSpecList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpecList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpecList_Append" "', argument " "1"" of type '" "lldb::SBModuleSpecList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpecList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBModuleSpecList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModuleSpecList_Append" "', argument " "2"" of type '" "lldb::SBModuleSpecList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModuleSpecList_Append" "', argument " "2"" of type '" "lldb::SBModuleSpecList const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBModuleSpecList * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Append((lldb::SBModuleSpecList const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpecList_Append(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBModuleSpecList_Append", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBModuleSpecList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBModuleSpecList_Append__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBModuleSpecList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBModuleSpecList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBModuleSpecList_Append__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBModuleSpecList_Append'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBModuleSpecList::Append(lldb::SBModuleSpec const &)\n"
    "    lldb::SBModuleSpecList::Append(lldb::SBModuleSpecList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBModuleSpecList_FindFirstMatchingSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpecList *arg1 = 0 ;
  lldb::SBModuleSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBModuleSpec result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModuleSpecList_FindFirstMatchingSpec", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpecList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpecList_FindFirstMatchingSpec" "', argument " "1"" of type '" "lldb::SBModuleSpecList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpecList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBModuleSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModuleSpecList_FindFirstMatchingSpec" "', argument " "2"" of type '" "lldb::SBModuleSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModuleSpecList_FindFirstMatchingSpec" "', argument " "2"" of type '" "lldb::SBModuleSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBModuleSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindFirstMatchingSpec((lldb::SBModuleSpec const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBModuleSpec(result)), SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpecList_FindMatchingSpecs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpecList *arg1 = 0 ;
  lldb::SBModuleSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBModuleSpecList result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModuleSpecList_FindMatchingSpecs", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpecList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpecList_FindMatchingSpecs" "', argument " "1"" of type '" "lldb::SBModuleSpecList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpecList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBModuleSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModuleSpecList_FindMatchingSpecs" "', argument " "2"" of type '" "lldb::SBModuleSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModuleSpecList_FindMatchingSpecs" "', argument " "2"" of type '" "lldb::SBModuleSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBModuleSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindMatchingSpecs((lldb::SBModuleSpec const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBModuleSpecList(result)), SWIGTYPE_p_lldb__SBModuleSpecList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpecList_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpecList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpecList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpecList_GetSize" "', argument " "1"" of type '" "lldb::SBModuleSpecList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpecList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpecList_GetSpecAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpecList *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBModuleSpec result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModuleSpecList_GetSpecAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpecList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpecList_GetSpecAtIndex" "', argument " "1"" of type '" "lldb::SBModuleSpecList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpecList * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBModuleSpecList_GetSpecAtIndex" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSpecAtIndex(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBModuleSpec(result)), SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpecList_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpecList *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBModuleSpecList_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpecList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpecList_GetDescription" "', argument " "1"" of type '" "lldb::SBModuleSpecList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpecList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBModuleSpecList_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBModuleSpecList_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBModuleSpecList___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBModuleSpecList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBModuleSpecList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBModuleSpecList___repr__" "', argument " "1"" of type '" "lldb::SBModuleSpecList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBModuleSpecList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBModuleSpecList___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBModuleSpecList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBModuleSpecList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBModuleSpecList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBMutex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBMutex *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBMutex *)new lldb::SBMutex();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBMutex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMutex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBMutex *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBMutex,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMutex" "', argument " "1"" of type '" "lldb::SBMutex const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBMutex" "', argument " "1"" of type '" "lldb::SBMutex const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMutex * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBMutex *)new lldb::SBMutex((lldb::SBMutex const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBMutex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMutex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMutex", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMutex__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBMutex, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMutex__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMutex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBMutex::SBMutex()\n"
    "    lldb::SBMutex::SBMutex(lldb::SBMutex const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBMutex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMutex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMutex" "', argument " "1"" of type '" "lldb::SBMutex *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMutex * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMutex_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMutex_IsValid" "', argument " "1"" of type '" "lldb::SBMutex const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMutex * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBMutex const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMutex_lock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMutex_lock" "', argument " "1"" of type '" "lldb::SBMutex const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMutex * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    ((lldb::SBMutex const *)arg1)->lock();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMutex_unlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMutex_unlock" "', argument " "1"" of type '" "lldb::SBMutex const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMutex * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    ((lldb::SBMutex const *)arg1)->unlock();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMutex_try_lock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMutex_try_lock" "', argument " "1"" of type '" "lldb::SBMutex const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBMutex * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBMutex const *)arg1)->try_lock();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMutex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBMutex, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMutex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBPlatformConnectOptions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  lldb::SBPlatformConnectOptions *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBPlatformConnectOptions" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBPlatformConnectOptions *)new lldb::SBPlatformConnectOptions((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBPlatformConnectOptions, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBPlatformConnectOptions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBPlatformConnectOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBPlatformConnectOptions *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBPlatformConnectOptions,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBPlatformConnectOptions" "', argument " "1"" of type '" "lldb::SBPlatformConnectOptions const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBPlatformConnectOptions" "', argument " "1"" of type '" "lldb::SBPlatformConnectOptions const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformConnectOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBPlatformConnectOptions *)new lldb::SBPlatformConnectOptions((lldb::SBPlatformConnectOptions const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBPlatformConnectOptions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBPlatformConnectOptions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBPlatformConnectOptions", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBPlatformConnectOptions, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBPlatformConnectOptions__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBPlatformConnectOptions__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBPlatformConnectOptions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBPlatformConnectOptions::SBPlatformConnectOptions(char const *)\n"
    "    lldb::SBPlatformConnectOptions::SBPlatformConnectOptions(lldb::SBPlatformConnectOptions const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBPlatformConnectOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformConnectOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformConnectOptions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBPlatformConnectOptions" "', argument " "1"" of type '" "lldb::SBPlatformConnectOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformConnectOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_GetURL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformConnectOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformConnectOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformConnectOptions_GetURL" "', argument " "1"" of type '" "lldb::SBPlatformConnectOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformConnectOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetURL();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_SetURL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformConnectOptions *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatformConnectOptions_SetURL", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformConnectOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformConnectOptions_SetURL" "', argument " "1"" of type '" "lldb::SBPlatformConnectOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformConnectOptions * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatformConnectOptions_SetURL" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetURL((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_GetRsyncEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformConnectOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformConnectOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformConnectOptions_GetRsyncEnabled" "', argument " "1"" of type '" "lldb::SBPlatformConnectOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformConnectOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetRsyncEnabled();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_EnableRsync(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformConnectOptions *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatformConnectOptions_EnableRsync", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformConnectOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformConnectOptions_EnableRsync" "', argument " "1"" of type '" "lldb::SBPlatformConnectOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformConnectOptions * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatformConnectOptions_EnableRsync" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBPlatformConnectOptions_EnableRsync" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBPlatformConnectOptions_EnableRsync" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->EnableRsync((char const *)arg2,(char const *)arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_DisableRsync(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformConnectOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformConnectOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformConnectOptions_DisableRsync" "', argument " "1"" of type '" "lldb::SBPlatformConnectOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformConnectOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->DisableRsync();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_GetLocalCacheDirectory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformConnectOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformConnectOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformConnectOptions_GetLocalCacheDirectory" "', argument " "1"" of type '" "lldb::SBPlatformConnectOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformConnectOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetLocalCacheDirectory();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformConnectOptions_SetLocalCacheDirectory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformConnectOptions *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatformConnectOptions_SetLocalCacheDirectory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformConnectOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformConnectOptions_SetLocalCacheDirectory" "', argument " "1"" of type '" "lldb::SBPlatformConnectOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformConnectOptions * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatformConnectOptions_SetLocalCacheDirectory" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetLocalCacheDirectory((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *SBPlatformConnectOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBPlatformConnectOptions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBPlatformConnectOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBPlatformShellCommand__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBPlatformShellCommand *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBPlatformShellCommand" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBPlatformShellCommand" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBPlatformShellCommand *)new lldb::SBPlatformShellCommand((char const *)arg1,(char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBPlatformShellCommand, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBPlatformShellCommand__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  lldb::SBPlatformShellCommand *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBPlatformShellCommand" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBPlatformShellCommand *)new lldb::SBPlatformShellCommand((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBPlatformShellCommand, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBPlatformShellCommand__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBPlatformShellCommand *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBPlatformShellCommand *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBPlatformShellCommand,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBPlatformShellCommand" "', argument " "1"" of type '" "lldb::SBPlatformShellCommand const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBPlatformShellCommand" "', argument " "1"" of type '" "lldb::SBPlatformShellCommand const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformShellCommand * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBPlatformShellCommand *)new lldb::SBPlatformShellCommand((lldb::SBPlatformShellCommand const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBPlatformShellCommand, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBPlatformShellCommand(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBPlatformShellCommand", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBPlatformShellCommand, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBPlatformShellCommand__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBPlatformShellCommand__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SBPlatformShellCommand__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBPlatformShellCommand'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBPlatformShellCommand::SBPlatformShellCommand(char const *,char const *)\n"
    "    lldb::SBPlatformShellCommand::SBPlatformShellCommand(char const *)\n"
    "    lldb::SBPlatformShellCommand::SBPlatformShellCommand(lldb::SBPlatformShellCommand const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBPlatformShellCommand(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformShellCommand *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformShellCommand, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBPlatformShellCommand" "', argument " "1"" of type '" "lldb::SBPlatformShellCommand *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformShellCommand * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformShellCommand *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformShellCommand, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformShellCommand_Clear" "', argument " "1"" of type '" "lldb::SBPlatformShellCommand *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformShellCommand * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetShell(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformShellCommand *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformShellCommand, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformShellCommand_GetShell" "', argument " "1"" of type '" "lldb::SBPlatformShellCommand *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformShellCommand * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetShell();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_SetShell(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformShellCommand *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatformShellCommand_SetShell", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformShellCommand, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformShellCommand_SetShell" "', argument " "1"" of type '" "lldb::SBPlatformShellCommand *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformShellCommand * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatformShellCommand_SetShell" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetShell((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetCommand(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformShellCommand *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformShellCommand, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformShellCommand_GetCommand" "', argument " "1"" of type '" "lldb::SBPlatformShellCommand *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformShellCommand * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetCommand();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_SetCommand(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformShellCommand *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatformShellCommand_SetCommand", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformShellCommand, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformShellCommand_SetCommand" "', argument " "1"" of type '" "lldb::SBPlatformShellCommand *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformShellCommand * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatformShellCommand_SetCommand" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetCommand((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetWorkingDirectory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformShellCommand *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformShellCommand, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformShellCommand_GetWorkingDirectory" "', argument " "1"" of type '" "lldb::SBPlatformShellCommand *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformShellCommand * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetWorkingDirectory();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_SetWorkingDirectory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformShellCommand *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatformShellCommand_SetWorkingDirectory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformShellCommand, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformShellCommand_SetWorkingDirectory" "', argument " "1"" of type '" "lldb::SBPlatformShellCommand *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformShellCommand * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatformShellCommand_SetWorkingDirectory" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetWorkingDirectory((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetTimeoutSeconds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformShellCommand *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformShellCommand, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformShellCommand_GetTimeoutSeconds" "', argument " "1"" of type '" "lldb::SBPlatformShellCommand *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformShellCommand * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetTimeoutSeconds();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_SetTimeoutSeconds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformShellCommand *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatformShellCommand_SetTimeoutSeconds", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformShellCommand, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformShellCommand_SetTimeoutSeconds" "', argument " "1"" of type '" "lldb::SBPlatformShellCommand *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformShellCommand * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBPlatformShellCommand_SetTimeoutSeconds" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetTimeoutSeconds(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetSignal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformShellCommand *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformShellCommand, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformShellCommand_GetSignal" "', argument " "1"" of type '" "lldb::SBPlatformShellCommand *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformShellCommand * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)(arg1)->GetSignal();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetStatus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformShellCommand *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformShellCommand, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformShellCommand_GetStatus" "', argument " "1"" of type '" "lldb::SBPlatformShellCommand *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformShellCommand * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)(arg1)->GetStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatformShellCommand_GetOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatformShellCommand *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatformShellCommand, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatformShellCommand_GetOutput" "', argument " "1"" of type '" "lldb::SBPlatformShellCommand *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatformShellCommand * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetOutput();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBPlatformShellCommand_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBPlatformShellCommand, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBPlatformShellCommand_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBPlatform__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBPlatform *)new lldb::SBPlatform();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBPlatform, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBPlatform__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  lldb::SBPlatform *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBPlatform" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBPlatform *)new lldb::SBPlatform((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBPlatform, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBPlatform__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBPlatform *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBPlatform,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBPlatform" "', argument " "1"" of type '" "lldb::SBPlatform const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBPlatform" "', argument " "1"" of type '" "lldb::SBPlatform const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBPlatform *)new lldb::SBPlatform((lldb::SBPlatform const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBPlatform, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBPlatform(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBPlatform", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBPlatform__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBPlatform, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBPlatform__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBPlatform__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBPlatform'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBPlatform::SBPlatform()\n"
    "    lldb::SBPlatform::SBPlatform(char const *)\n"
    "    lldb::SBPlatform::SBPlatform(lldb::SBPlatform const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBPlatform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBPlatform" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_GetHostPlatform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatform_GetHostPlatform", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBPlatform::GetHostPlatform();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBPlatform(result)), SWIGTYPE_p_lldb__SBPlatform, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform___nonzero__" "', argument " "1"" of type '" "lldb::SBPlatform const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBPlatform const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_IsValid" "', argument " "1"" of type '" "lldb::SBPlatform const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBPlatform const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_IsHost(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_IsHost" "', argument " "1"" of type '" "lldb::SBPlatform const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBPlatform const *)arg1)->IsHost();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_Clear" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_GetWorkingDirectory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_GetWorkingDirectory" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetWorkingDirectory();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_SetWorkingDirectory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatform_SetWorkingDirectory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_SetWorkingDirectory" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatform_SetWorkingDirectory" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetWorkingDirectory((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_GetName" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_ConnectRemote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  lldb::SBPlatformConnectOptions *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatform_ConnectRemote", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_ConnectRemote" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBPlatformConnectOptions,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatform_ConnectRemote" "', argument " "2"" of type '" "lldb::SBPlatformConnectOptions &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBPlatform_ConnectRemote" "', argument " "2"" of type '" "lldb::SBPlatformConnectOptions &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBPlatformConnectOptions * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ConnectRemote(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_DisconnectRemote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_DisconnectRemote" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->DisconnectRemote();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_IsConnected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_IsConnected" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsConnected();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_GetTriple(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_GetTriple" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetTriple();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_GetHostname(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_GetHostname" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetHostname();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_GetOSBuild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_GetOSBuild" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetOSBuild();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_GetOSDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_GetOSDescription" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetOSDescription();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_GetOSMajorVersion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_GetOSMajorVersion" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetOSMajorVersion();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_GetOSMinorVersion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_GetOSMinorVersion" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetOSMinorVersion();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_GetOSUpdateVersion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_GetOSUpdateVersion" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetOSUpdateVersion();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_SetSDKRoot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatform_SetSDKRoot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_SetSDKRoot" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatform_SetSDKRoot" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetSDKRoot((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_Put(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  lldb::SBFileSpec *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatform_Put", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_Put" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatform_Put" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBPlatform_Put" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBPlatform_Put" "', argument " "3"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBPlatform_Put" "', argument " "3"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpec * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Put(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_Get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  lldb::SBFileSpec *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatform_Get", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_Get" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatform_Get" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBPlatform_Get" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBPlatform_Get" "', argument " "3"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBPlatform_Get" "', argument " "3"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpec * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Get(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_Install(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  lldb::SBFileSpec *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatform_Install", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_Install" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatform_Install" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBPlatform_Install" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBPlatform_Install" "', argument " "3"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBPlatform_Install" "', argument " "3"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpec * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Install(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_Run(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  lldb::SBPlatformShellCommand *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatform_Run", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_Run" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBPlatformShellCommand,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatform_Run" "', argument " "2"" of type '" "lldb::SBPlatformShellCommand &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBPlatform_Run" "', argument " "2"" of type '" "lldb::SBPlatformShellCommand &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBPlatformShellCommand * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Run(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_Launch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  lldb::SBLaunchInfo *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatform_Launch", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_Launch" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBLaunchInfo,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatform_Launch" "', argument " "2"" of type '" "lldb::SBLaunchInfo &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBPlatform_Launch" "', argument " "2"" of type '" "lldb::SBLaunchInfo &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBLaunchInfo * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Launch(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_Attach(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  lldb::SBAttachInfo *arg2 = 0 ;
  lldb::SBDebugger *arg3 = 0 ;
  lldb::SBTarget *arg4 = 0 ;
  lldb::SBError *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  lldb::SBProcess result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatform_Attach", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_Attach" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAttachInfo,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatform_Attach" "', argument " "2"" of type '" "lldb::SBAttachInfo &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBPlatform_Attach" "', argument " "2"" of type '" "lldb::SBAttachInfo &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAttachInfo * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBDebugger,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBPlatform_Attach" "', argument " "3"" of type '" "lldb::SBDebugger const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBPlatform_Attach" "', argument " "3"" of type '" "lldb::SBDebugger const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBDebugger * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBTarget,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBPlatform_Attach" "', argument " "4"" of type '" "lldb::SBTarget &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBPlatform_Attach" "', argument " "4"" of type '" "lldb::SBTarget &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBTarget * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBPlatform_Attach" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBPlatform_Attach" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBError * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Attach(*arg2,(lldb::SBDebugger const &)*arg3,*arg4,*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_GetAllProcesses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBProcessInfoList result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatform_GetAllProcesses", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_GetAllProcesses" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatform_GetAllProcesses" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBPlatform_GetAllProcesses" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetAllProcesses(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcessInfoList(result)), SWIGTYPE_p_lldb__SBProcessInfoList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_Kill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  lldb::pid_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatform_Kill", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_Kill" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBPlatform_Kill" "', argument " "2"" of type '" "lldb::pid_t""'");
  } 
  arg2 = static_cast< lldb::pid_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Kill(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_MakeDirectory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_MakeDirectory" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatform_MakeDirectory" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBPlatform_MakeDirectory" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->MakeDirectory((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_MakeDirectory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_MakeDirectory" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatform_MakeDirectory" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->MakeDirectory((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_MakeDirectory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBPlatform_MakeDirectory", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBPlatform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBPlatform_MakeDirectory__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBPlatform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBPlatform_MakeDirectory__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBPlatform_MakeDirectory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBPlatform::MakeDirectory(char const *,uint32_t)\n"
    "    lldb::SBPlatform::MakeDirectory(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBPlatform_GetFilePermissions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatform_GetFilePermissions", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_GetFilePermissions" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatform_GetFilePermissions" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetFilePermissions((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_SetFilePermissions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatform_SetFilePermissions", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_SetFilePermissions" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBPlatform_SetFilePermissions" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBPlatform_SetFilePermissions" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetFilePermissions((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_GetUnixSignals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBUnixSignals result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_GetUnixSignals" "', argument " "1"" of type '" "lldb::SBPlatform const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBPlatform const *)arg1)->GetUnixSignals();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBUnixSignals(result)), SWIGTYPE_p_lldb__SBUnixSignals, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_GetEnvironment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBEnvironment result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_GetEnvironment" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetEnvironment();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBEnvironment(result)), SWIGTYPE_p_lldb__SBEnvironment, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBPlatform_SetLocateModuleCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBPlatform *arg1 = 0 ;
  lldb::SBPlatformLocateModuleCallback arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBPlatform_SetLocateModuleCallback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBPlatform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBPlatform_SetLocateModuleCallback" "', argument " "1"" of type '" "lldb::SBPlatform *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBPlatform * >(argp1);
  {
    if (!(swig_obj[1] == Py_None ||
        PyCallable_Check(reinterpret_cast<PyObject *>(swig_obj[1])))) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object or None!");
      SWIG_fail;
    }
    
    if (swig_obj[1] == Py_None) {
      arg2 = nullptr;
      arg3 = nullptr;
    } else {
      PythonCallable callable = Retain<PythonCallable>(swig_obj[1]);
      if (!callable.IsValid()) {
        PyErr_SetString(PyExc_TypeError, "Need a valid callable object");
        SWIG_fail;
      }
      
      llvm::Expected<PythonCallable::ArgInfo> arg_info = callable.GetArgInfo();
      if (!arg_info) {
        PyErr_SetString(PyExc_TypeError,
          ("Could not get arguments: " +
            llvm::toString(arg_info.takeError())).c_str());
        SWIG_fail;
      }
      
      if (arg_info.get().max_positional_args != 3) {
        PyErr_SetString(PyExc_TypeError, "Expected 3 argument callable object");
        SWIG_fail;
      }
      
      // NOTE: When this is called multiple times, this will leak the Python
      // callable object as other callbacks, because this does not call Py_DECREF
      // the object. But it should be almost zero impact since this method is
      // expected to be called only once.
      
      // Don't lose the callback reference
      Py_INCREF(swig_obj[1]);
      
      arg2 = LLDBSwigPythonCallLocateModuleCallback;
      arg3 = swig_obj[1];
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetLocateModuleCallback(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBPlatform_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBPlatform, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBPlatform_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBProcess__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBProcess *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBProcess *)new lldb::SBProcess();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBProcess__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBProcess *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBProcess,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBProcess" "', argument " "1"" of type '" "lldb::SBProcess const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBProcess" "', argument " "1"" of type '" "lldb::SBProcess const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBProcess *)new lldb::SBProcess((lldb::SBProcess const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBProcess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBProcess", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBProcess__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBProcess__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBProcess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBProcess::SBProcess()\n"
    "    lldb::SBProcess::SBProcess(lldb::SBProcess const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBProcess" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetBroadcasterClassName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetBroadcasterClassName", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBProcess::GetBroadcasterClassName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetPluginName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetPluginName" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetPluginName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetShortPluginName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetShortPluginName" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetShortPluginName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_Clear" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess___nonzero__" "', argument " "1"" of type '" "lldb::SBProcess const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBProcess const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_IsValid" "', argument " "1"" of type '" "lldb::SBProcess const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBProcess const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTarget result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetTarget" "', argument " "1"" of type '" "lldb::SBProcess const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBProcess const *)arg1)->GetTarget();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetByteOrder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::ByteOrder result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetByteOrder" "', argument " "1"" of type '" "lldb::SBProcess const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ByteOrder)((lldb::SBProcess const *)arg1)->GetByteOrder();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_PutSTDIN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  char *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_PutSTDIN", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_PutSTDIN" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    if (PythonString::Check(swig_obj[1])) {
      PythonString str(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (char *)str.GetString().data();
      arg3 = str.GetSize();
    } else if (PythonByteArray::Check(swig_obj[1])) {
      PythonByteArray bytearray(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (char *)bytearray.GetBytes().data();
      arg3 = bytearray.GetSize();
    } else if (PythonBytes::Check(swig_obj[1])) {
      PythonBytes bytes(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (char *)bytes.GetBytes().data();
      arg3 = bytes.GetSize();
    } else {
      PyErr_SetString(PyExc_ValueError, "Expecting a string");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->PutSTDIN((char const *)arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetSTDOUT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  char *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetSTDOUT", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetSTDOUT" "', argument " "1"" of type '" "lldb::SBProcess const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    if (!PyLong_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError, "Expecting an integer");
      SWIG_fail;
    }
    arg3 = PyLong_AsLong(swig_obj[1]);
    if (arg3 <= 0) {
      PyErr_SetString(PyExc_ValueError, "Positive integer expected");
      SWIG_fail;
    }
    arg2 = (char *)malloc(arg3);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBProcess const *)arg1)->GetSTDOUT(arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  {
    Py_XDECREF(resultobj); /* Blow away any previous result */
    if (result == 0) {
      PythonString string("");
      resultobj = string.release();
      Py_INCREF(resultobj);
    } else {
      llvm::StringRef ref(static_cast<const char *>(arg2), result);
      PythonString string(ref);
      resultobj = string.release();
    }
    free(arg2);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetSTDERR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  char *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetSTDERR", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetSTDERR" "', argument " "1"" of type '" "lldb::SBProcess const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    if (!PyLong_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError, "Expecting an integer");
      SWIG_fail;
    }
    arg3 = PyLong_AsLong(swig_obj[1]);
    if (arg3 <= 0) {
      PyErr_SetString(PyExc_ValueError, "Positive integer expected");
      SWIG_fail;
    }
    arg2 = (char *)malloc(arg3);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBProcess const *)arg1)->GetSTDERR(arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  {
    Py_XDECREF(resultobj); /* Blow away any previous result */
    if (result == 0) {
      PythonString string("");
      resultobj = string.release();
      Py_INCREF(resultobj);
    } else {
      llvm::StringRef ref(static_cast<const char *>(arg2), result);
      PythonString string(ref);
      resultobj = string.release();
    }
    free(arg2);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetAsyncProfileData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  char *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetAsyncProfileData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetAsyncProfileData" "', argument " "1"" of type '" "lldb::SBProcess const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    if (!PyLong_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError, "Expecting an integer");
      SWIG_fail;
    }
    arg3 = PyLong_AsLong(swig_obj[1]);
    if (arg3 <= 0) {
      PyErr_SetString(PyExc_ValueError, "Positive integer expected");
      SWIG_fail;
    }
    arg2 = (char *)malloc(arg3);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBProcess const *)arg1)->GetAsyncProfileData(arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  {
    Py_XDECREF(resultobj); /* Blow away any previous result */
    if (result == 0) {
      PythonString string("");
      resultobj = string.release();
      Py_INCREF(resultobj);
    } else {
      llvm::StringRef ref(static_cast<const char *>(arg2), result);
      PythonString string(ref);
      resultobj = string.release();
    }
    free(arg2);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_ReportEventState__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::SBEvent *arg2 = 0 ;
  lldb::SBFile arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_ReportEventState" "', argument " "1"" of type '" "lldb::SBProcess const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBProcess_ReportEventState" "', argument " "2"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_ReportEventState" "', argument " "2"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBEvent * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFile,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBProcess_ReportEventState" "', argument " "3"" of type '" "lldb::SBFile""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_ReportEventState" "', argument " "3"" of type '" "lldb::SBFile""'");
    } else {
      lldb::SBFile * temp = reinterpret_cast< lldb::SBFile * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    ((lldb::SBProcess const *)arg1)->ReportEventState((lldb::SBEvent const &)*arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_ReportEventState__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::SBEvent *arg2 = 0 ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_ReportEventState" "', argument " "1"" of type '" "lldb::SBProcess const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBProcess_ReportEventState" "', argument " "2"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_ReportEventState" "', argument " "2"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBEvent * >(argp2);
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[2]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp =
    unwrapOrSetPythonException(py_file.ConvertToFile(/*borrowed=*/true));
    if (!sp)
    SWIG_fail;
    arg3 = sp;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    ((lldb::SBProcess const *)arg1)->ReportEventState((lldb::SBEvent const &)*arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_ReportEventState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBProcess_ReportEventState", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBProcess_ReportEventState__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          if (PythonFile::Check(argv[2])) {
            _v = 1;
          } else {
            PyErr_Clear();
            _v = 0;
          }
        }
        if (_v) {
          return _wrap_SBProcess_ReportEventState__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBProcess_ReportEventState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBProcess::ReportEventState(lldb::SBEvent const &,lldb::SBFile) const\n"
    "    lldb::SBProcess::ReportEventState(lldb::SBEvent const &,lldb::FileSP) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBProcess_AppendEventStateReport(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::SBEvent *arg2 = 0 ;
  lldb::SBCommandReturnObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_AppendEventStateReport", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_AppendEventStateReport" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBProcess_AppendEventStateReport" "', argument " "2"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_AppendEventStateReport" "', argument " "2"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBEvent * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBCommandReturnObject,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBProcess_AppendEventStateReport" "', argument " "3"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_AppendEventStateReport" "', argument " "3"" of type '" "lldb::SBCommandReturnObject &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBCommandReturnObject * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->AppendEventStateReport((lldb::SBEvent const &)*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_RemoteAttachToProcessWithID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::pid_t arg2 ;
  lldb::SBError *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_RemoteAttachToProcessWithID", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_RemoteAttachToProcessWithID" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_RemoteAttachToProcessWithID" "', argument " "2"" of type '" "lldb::pid_t""'");
  } 
  arg2 = static_cast< lldb::pid_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBProcess_RemoteAttachToProcessWithID" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_RemoteAttachToProcessWithID" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBError * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->RemoteAttachToProcessWithID(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_RemoteLaunch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  char **arg2 = 0 ;
  char **arg3 = 0 ;
  char *arg4 = 0 ;
  char *arg5 = 0 ;
  char *arg6 = 0 ;
  char *arg7 = 0 ;
  uint32_t arg8 ;
  bool arg9 ;
  lldb::SBError *arg10 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  int res7 ;
  char *buf7 = 0 ;
  int alloc7 = 0 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  PyObject *swig_obj[10] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_RemoteLaunch", 10, 10, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_RemoteLaunch" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    /* Check if is a list  */
    if (PythonList::Check(swig_obj[1])) {
      PythonList list(PyRefType::Borrowed, swig_obj[1]);
      int size = list.GetSize();
      int i = 0;
      arg2 = (char **)malloc((size + 1) * sizeof(char *));
      for (i = 0; i < size; i++) {
        PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
        if (!py_str.IsAllocated()) {
          PyErr_SetString(PyExc_TypeError, "list must contain strings");
          SWIG_fail;
        }
        
        arg2[i] = const_cast<char *>(py_str.GetString().data());
      }
      arg2[i] = 0;
    } else if (swig_obj[1] == Py_None) {
      arg2 = NULL;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  {
    /* Check if is a list  */
    if (PythonList::Check(swig_obj[2])) {
      PythonList list(PyRefType::Borrowed, swig_obj[2]);
      int size = list.GetSize();
      int i = 0;
      arg3 = (char **)malloc((size + 1) * sizeof(char *));
      for (i = 0; i < size; i++) {
        PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
        if (!py_str.IsAllocated()) {
          PyErr_SetString(PyExc_TypeError, "list must contain strings");
          SWIG_fail;
        }
        
        arg3[i] = const_cast<char *>(py_str.GetString().data());
      }
      arg3[i] = 0;
    } else if (swig_obj[2] == Py_None) {
      arg3 = NULL;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBProcess_RemoteLaunch" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBProcess_RemoteLaunch" "', argument " "5"" of type '" "char const *""'");
  }
  arg5 = reinterpret_cast< char * >(buf5);
  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SBProcess_RemoteLaunch" "', argument " "6"" of type '" "char const *""'");
  }
  arg6 = reinterpret_cast< char * >(buf6);
  res7 = SWIG_AsCharPtrAndSize(swig_obj[6], &buf7, NULL, &alloc7);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SBProcess_RemoteLaunch" "', argument " "7"" of type '" "char const *""'");
  }
  arg7 = reinterpret_cast< char * >(buf7);
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SBProcess_RemoteLaunch" "', argument " "8"" of type '" "uint32_t""'");
  } 
  arg8 = static_cast< uint32_t >(val8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SBProcess_RemoteLaunch" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "SBProcess_RemoteLaunch" "', argument " "10"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_RemoteLaunch" "', argument " "10"" of type '" "lldb::SBError &""'"); 
  }
  arg10 = reinterpret_cast< lldb::SBError * >(argp10);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->RemoteLaunch((char const **)arg2,(char const **)arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,arg8,arg9,*arg10);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    free((char *) arg2);
  }
  {
    free((char *) arg3);
  }
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
  return resultobj;
fail:
  {
    free((char *) arg2);
  }
  {
    free((char *) arg3);
  }
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetNumThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetNumThreads" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumThreads();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetThreadAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBThread result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetThreadAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetThreadAtIndex" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_GetThreadAtIndex" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetThreadAtIndex(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetThreadByID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::tid_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBThread result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetThreadByID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetThreadByID" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    PythonObject obj = Retain<PythonObject>(swig_obj[1]);
    lldb::tid_t value = unwrapOrSetPythonException(As<unsigned long long>(obj));
    if (PyErr_Occurred())
    SWIG_fail;
    arg2 = value;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetThreadByID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetThreadByIndexID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBThread result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetThreadByIndexID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetThreadByIndexID" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_GetThreadByIndexID" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetThreadByIndexID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetSelectedThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBThread result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetSelectedThread" "', argument " "1"" of type '" "lldb::SBProcess const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBProcess const *)arg1)->GetSelectedThread();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_CreateOSPluginThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::tid_t arg2 ;
  lldb::addr_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBThread result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_CreateOSPluginThread", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_CreateOSPluginThread" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    PythonObject obj = Retain<PythonObject>(swig_obj[1]);
    lldb::tid_t value = unwrapOrSetPythonException(As<unsigned long long>(obj));
    if (PyErr_Occurred())
    SWIG_fail;
    arg2 = value;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBProcess_CreateOSPluginThread" "', argument " "3"" of type '" "lldb::addr_t""'");
  } 
  arg3 = static_cast< lldb::addr_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateOSPluginThread(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_SetSelectedThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::SBThread *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_SetSelectedThread", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_SetSelectedThread" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBThread,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBProcess_SetSelectedThread" "', argument " "2"" of type '" "lldb::SBThread const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_SetSelectedThread" "', argument " "2"" of type '" "lldb::SBThread const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBThread * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetSelectedThread((lldb::SBThread const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_SetSelectedThreadByID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::tid_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_SetSelectedThreadByID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_SetSelectedThreadByID" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    PythonObject obj = Retain<PythonObject>(swig_obj[1]);
    lldb::tid_t value = unwrapOrSetPythonException(As<unsigned long long>(obj));
    if (PyErr_Occurred())
    SWIG_fail;
    arg2 = value;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetSelectedThreadByID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_SetSelectedThreadByIndexID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_SetSelectedThreadByIndexID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_SetSelectedThreadByIndexID" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_SetSelectedThreadByIndexID" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetSelectedThreadByIndexID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetNumQueues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetNumQueues" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumQueues();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetQueueAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBQueue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetQueueAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetQueueAtIndex" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_GetQueueAtIndex" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetQueueAtIndex(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBQueue(result)), SWIGTYPE_p_lldb__SBQueue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::StateType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetState" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::StateType)(arg1)->GetState();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetExitStatus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetExitStatus" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)(arg1)->GetExitStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetExitDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetExitDescription" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetExitDescription();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetProcessID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::pid_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetProcessID" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::pid_t)(arg1)->GetProcessID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetUniqueID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetUniqueID" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetUniqueID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetAddressByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetAddressByteSize" "', argument " "1"" of type '" "lldb::SBProcess const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBProcess const *)arg1)->GetAddressByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_Destroy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBError result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_Destroy" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Destroy();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_Continue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBError result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_Continue" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Continue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_ContinueInDirection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::RunDirection arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_ContinueInDirection", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_ContinueInDirection" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_ContinueInDirection" "', argument " "2"" of type '" "lldb::RunDirection""'");
  } 
  arg2 = static_cast< lldb::RunDirection >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ContinueInDirection(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_Stop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBError result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_Stop" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Stop();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_Kill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBError result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_Kill" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Kill();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_Detach__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_Detach" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Detach();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_Detach__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_Detach" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_Detach" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Detach(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_Detach(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBProcess_Detach", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBProcess_Detach__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBProcess_Detach__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBProcess_Detach'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBProcess::Detach()\n"
    "    lldb::SBProcess::Detach(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBProcess_Signal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_Signal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_Signal" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_Signal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Signal(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetUnixSignals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBUnixSignals result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetUnixSignals" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetUnixSignals();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBUnixSignals(result)), SWIGTYPE_p_lldb__SBUnixSignals, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_SendAsyncInterrupt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_SendAsyncInterrupt" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SendAsyncInterrupt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetStopID__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  uint32_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetStopID" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_GetStopID" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetStopID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetStopID__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint32_t result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetStopID" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetStopID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetStopID(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBProcess_GetStopID", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBProcess_GetStopID__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBProcess_GetStopID__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBProcess_GetStopID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBProcess::GetStopID(bool)\n"
    "    lldb::SBProcess::GetStopID()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetStopEventForStopID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBEvent result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetStopEventForStopID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetStopEventForStopID" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_GetStopEventForStopID" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetStopEventForStopID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBEvent(result)), SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_ForceScriptedState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::StateType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_ForceScriptedState", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_ForceScriptedState" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    PythonObject obj = Retain<PythonObject>(swig_obj[1]);
    unsigned long long state_type_value =
    unwrapOrSetPythonException(As<unsigned long long>(obj));
    if (PyErr_Occurred())
    SWIG_fail;
    if (state_type_value > lldb::StateType::kLastStateType) {
      PyErr_SetString(PyExc_ValueError, "Not a valid StateType value");
      SWIG_fail;
    }
    arg2 = static_cast<lldb::StateType>(state_type_value);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->ForceScriptedState(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_ReadMemory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::addr_t arg2 ;
  void *arg3 = 0 ;
  size_t arg4 ;
  lldb::SBError *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[4] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_ReadMemory", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_ReadMemory" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_ReadMemory" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    if (PyLong_Check(swig_obj[2])) {
      arg4 = PyLong_AsLong(swig_obj[2]);
    } else {
      PyErr_SetString(PyExc_ValueError, "Expecting an integer or long object");
      SWIG_fail;
    }
    if (arg4 <= 0) {
      PyErr_SetString(PyExc_ValueError, "Positive integer expected");
      SWIG_fail;
    }
    arg3 = (void *)malloc(arg4);
  }
  res5 = SWIG_ConvertPtr(swig_obj[3], &argp5, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBProcess_ReadMemory" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_ReadMemory" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBError * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ReadMemory(arg2,arg3,SWIG_STD_MOVE(arg4),*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  {
    Py_XDECREF(resultobj); /* Blow away any previous result */
    if (result == 0) {
      resultobj = Py_None;
      Py_INCREF(resultobj);
    } else {
      PythonBytes bytes(static_cast<const uint8_t *>(arg3), result);
      resultobj = bytes.release();
    }
    free(arg3);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_WriteMemory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::addr_t arg2 ;
  void *arg3 = 0 ;
  size_t arg4 ;
  lldb::SBError *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[4] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_WriteMemory", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_WriteMemory" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_WriteMemory" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    if (PythonString::Check(swig_obj[2])) {
      PythonString str(PyRefType::Borrowed, swig_obj[2]);
      arg3 = (void *)str.GetString().data();
      arg4 = str.GetSize();
    } else if (PythonByteArray::Check(swig_obj[2])) {
      PythonByteArray bytearray(PyRefType::Borrowed, swig_obj[2]);
      arg3 = (void *)bytearray.GetBytes().data();
      arg4 = bytearray.GetSize();
    } else if (PythonBytes::Check(swig_obj[2])) {
      PythonBytes bytes(PyRefType::Borrowed, swig_obj[2]);
      arg3 = (void *)bytes.GetBytes().data();
      arg4 = bytes.GetSize();
    } else {
      PyErr_SetString(PyExc_ValueError, "Expecting a buffer");
      SWIG_fail;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[3], &argp5, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBProcess_WriteMemory" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_WriteMemory" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBError * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->WriteMemory(arg2,(void const *)arg3,SWIG_STD_MOVE(arg4),*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_ReadCStringFromMemory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::addr_t arg2 ;
  void *arg3 = 0 ;
  size_t arg4 ;
  lldb::SBError *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[4] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_ReadCStringFromMemory", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_ReadCStringFromMemory" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_ReadCStringFromMemory" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    if (!PyLong_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_ValueError, "Expecting an integer");
      SWIG_fail;
    }
    arg4 = PyLong_AsLong(swig_obj[2]);
    if (arg4 <= 0) {
      PyErr_SetString(PyExc_ValueError, "Positive integer expected");
      SWIG_fail;
    }
    arg3 = (char *)malloc(arg4);
  }
  res5 = SWIG_ConvertPtr(swig_obj[3], &argp5, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBProcess_ReadCStringFromMemory" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_ReadCStringFromMemory" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBError * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ReadCStringFromMemory(arg2,arg3,SWIG_STD_MOVE(arg4),*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  {
    Py_XDECREF(resultobj); /* Blow away any previous result */
    if (result == 0) {
      PythonString string("");
      resultobj = string.release();
      Py_INCREF(resultobj);
    } else {
      llvm::StringRef ref(static_cast<const char *>(arg3), result);
      PythonString string(ref);
      resultobj = string.release();
    }
    free(arg3);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_ReadUnsignedFromMemory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::addr_t arg2 ;
  uint32_t arg3 ;
  lldb::SBError *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  uint64_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_ReadUnsignedFromMemory", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_ReadUnsignedFromMemory" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_ReadUnsignedFromMemory" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBProcess_ReadUnsignedFromMemory" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBProcess_ReadUnsignedFromMemory" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_ReadUnsignedFromMemory" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBError * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->ReadUnsignedFromMemory(arg2,arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_ReadPointerFromMemory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::addr_t arg2 ;
  lldb::SBError *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::addr_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_ReadPointerFromMemory", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_ReadPointerFromMemory" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_ReadPointerFromMemory" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBProcess_ReadPointerFromMemory" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_ReadPointerFromMemory" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBError * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->ReadPointerFromMemory(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_FindRangesInMemory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *arg2 = 0 ;
  uint64_t arg3 ;
  lldb::SBAddressRangeList *arg4 = 0 ;
  uint32_t arg5 ;
  uint32_t arg6 ;
  lldb::SBError *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject *swig_obj[6] ;
  lldb::SBAddressRangeList result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_FindRangesInMemory", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_FindRangesInMemory" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    if (PythonString::Check(swig_obj[1])) {
      PythonString str(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (void *)str.GetString().data();
      arg3 = str.GetSize();
    } else if (PythonByteArray::Check(swig_obj[1])) {
      PythonByteArray bytearray(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (void *)bytearray.GetBytes().data();
      arg3 = bytearray.GetSize();
    } else if (PythonBytes::Check(swig_obj[1])) {
      PythonBytes bytes(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (void *)bytes.GetBytes().data();
      arg3 = bytes.GetSize();
    } else {
      PyErr_SetString(PyExc_ValueError, "Expecting a buffer");
      SWIG_fail;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[2], &argp4, SWIGTYPE_p_lldb__SBAddressRangeList,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBProcess_FindRangesInMemory" "', argument " "4"" of type '" "lldb::SBAddressRangeList const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_FindRangesInMemory" "', argument " "4"" of type '" "lldb::SBAddressRangeList const &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBAddressRangeList * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBProcess_FindRangesInMemory" "', argument " "5"" of type '" "uint32_t""'");
  } 
  arg5 = static_cast< uint32_t >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBProcess_FindRangesInMemory" "', argument " "6"" of type '" "uint32_t""'");
  } 
  arg6 = static_cast< uint32_t >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[5], &argp7, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SBProcess_FindRangesInMemory" "', argument " "7"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_FindRangesInMemory" "', argument " "7"" of type '" "lldb::SBError &""'"); 
  }
  arg7 = reinterpret_cast< lldb::SBError * >(argp7);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindRangesInMemory((void const *)arg2,arg3,(lldb::SBAddressRangeList const &)*arg4,arg5,arg6,*arg7);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddressRangeList(result)), SWIGTYPE_p_lldb__SBAddressRangeList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_FindInMemory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *arg2 = 0 ;
  uint64_t arg3 ;
  lldb::SBAddressRange *arg4 = 0 ;
  uint32_t arg5 ;
  lldb::SBError *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[5] ;
  lldb::addr_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_FindInMemory", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_FindInMemory" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    if (PythonString::Check(swig_obj[1])) {
      PythonString str(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (void *)str.GetString().data();
      arg3 = str.GetSize();
    } else if (PythonByteArray::Check(swig_obj[1])) {
      PythonByteArray bytearray(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (void *)bytearray.GetBytes().data();
      arg3 = bytearray.GetSize();
    } else if (PythonBytes::Check(swig_obj[1])) {
      PythonBytes bytes(PyRefType::Borrowed, swig_obj[1]);
      arg2 = (void *)bytes.GetBytes().data();
      arg3 = bytes.GetSize();
    } else {
      PyErr_SetString(PyExc_ValueError, "Expecting a buffer");
      SWIG_fail;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[2], &argp4, SWIGTYPE_p_lldb__SBAddressRange,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBProcess_FindInMemory" "', argument " "4"" of type '" "lldb::SBAddressRange const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_FindInMemory" "', argument " "4"" of type '" "lldb::SBAddressRange const &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBAddressRange * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBProcess_FindInMemory" "', argument " "5"" of type '" "uint32_t""'");
  } 
  arg5 = static_cast< uint32_t >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[4], &argp6, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SBProcess_FindInMemory" "', argument " "6"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_FindInMemory" "', argument " "6"" of type '" "lldb::SBError &""'"); 
  }
  arg6 = reinterpret_cast< lldb::SBError * >(argp6);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->FindInMemory((void const *)arg2,arg3,(lldb::SBAddressRange const &)*arg4,arg5,*arg6);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetStateFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::StateType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetStateFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_GetStateFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::StateType)lldb::SBProcess::GetStateFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetRestartedFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetRestartedFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_GetRestartedFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBProcess::GetRestartedFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetNumRestartedReasonsFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetNumRestartedReasonsFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_GetNumRestartedReasonsFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBProcess::GetNumRestartedReasonsFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetRestartedReasonAtIndexFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetRestartedReasonAtIndexFromEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetRestartedReasonAtIndexFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_GetRestartedReasonAtIndexFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_GetRestartedReasonAtIndexFromEvent" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBProcess::GetRestartedReasonAtIndexFromEvent((lldb::SBEvent const &)*arg1,SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetProcessFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBProcess result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetProcessFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_GetProcessFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBProcess::GetProcessFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetInterruptedFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetInterruptedFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_GetInterruptedFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBProcess::GetInterruptedFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetStructuredDataFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetStructuredDataFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_GetStructuredDataFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBProcess::GetStructuredDataFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_EventIsProcessEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_EventIsProcessEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_EventIsProcessEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBProcess::EventIsProcessEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_EventIsStructuredDataEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_EventIsStructuredDataEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_EventIsStructuredDataEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBProcess::EventIsStructuredDataEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetBroadcaster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBroadcaster result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetBroadcaster" "', argument " "1"" of type '" "lldb::SBProcess const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBProcess const *)arg1)->GetBroadcaster();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBroadcaster(result)), SWIGTYPE_p_lldb__SBBroadcaster, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetBroadcasterClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetBroadcasterClass", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBProcess::GetBroadcasterClass();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetDescription" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBProcess_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetExtendedCrashInformation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetExtendedCrashInformation" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetExtendedCrashInformation();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetNumSupportedHardwareWatchpoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetNumSupportedHardwareWatchpoints", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetNumSupportedHardwareWatchpoints" "', argument " "1"" of type '" "lldb::SBProcess const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBProcess_GetNumSupportedHardwareWatchpoints" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_GetNumSupportedHardwareWatchpoints" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBProcess const *)arg1)->GetNumSupportedHardwareWatchpoints(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_LoadImage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  lldb::SBError *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  uint32_t result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_LoadImage" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBProcess_LoadImage" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_LoadImage" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBProcess_LoadImage" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_LoadImage" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBError * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->LoadImage(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_LoadImage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  lldb::SBFileSpec *arg3 = 0 ;
  lldb::SBError *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  uint32_t result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_LoadImage" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBProcess_LoadImage" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_LoadImage" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBProcess_LoadImage" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_LoadImage" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpec * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBProcess_LoadImage" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_LoadImage" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBError * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->LoadImage((lldb::SBFileSpec const &)*arg2,(lldb::SBFileSpec const &)*arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_LoadImage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBProcess_LoadImage", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBProcess_LoadImage__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBProcess_LoadImage__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBProcess_LoadImage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBProcess::LoadImage(lldb::SBFileSpec &,lldb::SBError &)\n"
    "    lldb::SBProcess::LoadImage(lldb::SBFileSpec const &,lldb::SBFileSpec const &,lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBProcess_LoadImageUsingPaths(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  lldb::SBStringList *arg3 = 0 ;
  lldb::SBFileSpec *arg4 = 0 ;
  lldb::SBError *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_LoadImageUsingPaths", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_LoadImageUsingPaths" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBProcess_LoadImageUsingPaths" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_LoadImageUsingPaths" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStringList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBProcess_LoadImageUsingPaths" "', argument " "3"" of type '" "lldb::SBStringList &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_LoadImageUsingPaths" "', argument " "3"" of type '" "lldb::SBStringList &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBStringList * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBProcess_LoadImageUsingPaths" "', argument " "4"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_LoadImageUsingPaths" "', argument " "4"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBFileSpec * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBProcess_LoadImageUsingPaths" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_LoadImageUsingPaths" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBError * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->LoadImageUsingPaths((lldb::SBFileSpec const &)*arg2,*arg3,*arg4,*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_UnloadImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_UnloadImage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_UnloadImage" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_UnloadImage" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->UnloadImage(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_SendEventData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_SendEventData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_SendEventData" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBProcess_SendEventData" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SendEventData((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetNumExtendedBacktraceTypes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetNumExtendedBacktraceTypes" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumExtendedBacktraceTypes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetExtendedBacktraceTypeAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetExtendedBacktraceTypeAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetExtendedBacktraceTypeAtIndex" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_GetExtendedBacktraceTypeAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetExtendedBacktraceTypeAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetHistoryThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::addr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBThreadCollection result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetHistoryThreads", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetHistoryThreads" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_GetHistoryThreads" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetHistoryThreads(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThreadCollection(result)), SWIGTYPE_p_lldb__SBThreadCollection, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_IsInstrumentationRuntimePresent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::InstrumentationRuntimeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_IsInstrumentationRuntimePresent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_IsInstrumentationRuntimePresent" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_IsInstrumentationRuntimePresent" "', argument " "2"" of type '" "lldb::InstrumentationRuntimeType""'");
  } 
  arg2 = static_cast< lldb::InstrumentationRuntimeType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsInstrumentationRuntimePresent(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_SaveCore__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  lldb::SaveCoreStyle arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_SaveCore" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBProcess_SaveCore" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBProcess_SaveCore" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBProcess_SaveCore" "', argument " "4"" of type '" "lldb::SaveCoreStyle""'");
  } 
  arg4 = static_cast< lldb::SaveCoreStyle >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SaveCore((char const *)arg2,(char const *)arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_SaveCore__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_SaveCore" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBProcess_SaveCore" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SaveCore((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_SaveCore__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::SBSaveCoreOptions *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_SaveCore" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBSaveCoreOptions,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBProcess_SaveCore" "', argument " "2"" of type '" "lldb::SBSaveCoreOptions &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_SaveCore" "', argument " "2"" of type '" "lldb::SBSaveCoreOptions &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBSaveCoreOptions * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SaveCore(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_SaveCore(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBProcess_SaveCore", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBSaveCoreOptions, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBProcess_SaveCore__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBProcess_SaveCore__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBProcess_SaveCore__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBProcess_SaveCore'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBProcess::SaveCore(char const *,char const *,lldb::SaveCoreStyle)\n"
    "    lldb::SBProcess::SaveCore(char const *)\n"
    "    lldb::SBProcess::SaveCore(lldb::SBSaveCoreOptions &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetMemoryRegionInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::addr_t arg2 ;
  lldb::SBMemoryRegionInfo *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetMemoryRegionInfo", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetMemoryRegionInfo" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_GetMemoryRegionInfo" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBMemoryRegionInfo,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBProcess_GetMemoryRegionInfo" "', argument " "3"" of type '" "lldb::SBMemoryRegionInfo &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_GetMemoryRegionInfo" "', argument " "3"" of type '" "lldb::SBMemoryRegionInfo &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBMemoryRegionInfo * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetMemoryRegionInfo(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetMemoryRegions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBMemoryRegionInfoList result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetMemoryRegions" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetMemoryRegions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBMemoryRegionInfoList(result)), SWIGTYPE_p_lldb__SBMemoryRegionInfoList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetProcessInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBProcessInfo result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetProcessInfo" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetProcessInfo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcessInfo(result)), SWIGTYPE_p_lldb__SBProcessInfo, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetCoreFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetCoreFile" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetCoreFile();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetAddressMask__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::AddressMaskType arg2 ;
  lldb::AddressMaskRange arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  lldb::addr_t result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetAddressMask" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_GetAddressMask" "', argument " "2"" of type '" "lldb::AddressMaskType""'");
  } 
  arg2 = static_cast< lldb::AddressMaskType >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBProcess_GetAddressMask" "', argument " "3"" of type '" "lldb::AddressMaskRange""'");
  } 
  arg3 = static_cast< lldb::AddressMaskRange >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->GetAddressMask(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetAddressMask__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::AddressMaskType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  lldb::addr_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetAddressMask" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_GetAddressMask" "', argument " "2"" of type '" "lldb::AddressMaskType""'");
  } 
  arg2 = static_cast< lldb::AddressMaskType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->GetAddressMask(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetAddressMask(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBProcess_GetAddressMask", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBProcess_GetAddressMask__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBProcess_GetAddressMask__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBProcess_GetAddressMask'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBProcess::GetAddressMask(lldb::AddressMaskType,lldb::AddressMaskRange)\n"
    "    lldb::SBProcess::GetAddressMask(lldb::AddressMaskType)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBProcess_SetAddressMask__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::AddressMaskType arg2 ;
  lldb::addr_t arg3 ;
  lldb::AddressMaskRange arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_SetAddressMask" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_SetAddressMask" "', argument " "2"" of type '" "lldb::AddressMaskType""'");
  } 
  arg2 = static_cast< lldb::AddressMaskType >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBProcess_SetAddressMask" "', argument " "3"" of type '" "lldb::addr_t""'");
  } 
  arg3 = static_cast< lldb::addr_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBProcess_SetAddressMask" "', argument " "4"" of type '" "lldb::AddressMaskRange""'");
  } 
  arg4 = static_cast< lldb::AddressMaskRange >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAddressMask(arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_SetAddressMask__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::AddressMaskType arg2 ;
  lldb::addr_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_SetAddressMask" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_SetAddressMask" "', argument " "2"" of type '" "lldb::AddressMaskType""'");
  } 
  arg2 = static_cast< lldb::AddressMaskType >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBProcess_SetAddressMask" "', argument " "3"" of type '" "lldb::addr_t""'");
  } 
  arg3 = static_cast< lldb::addr_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAddressMask(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_SetAddressMask(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBProcess_SetAddressMask", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBProcess_SetAddressMask__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBProcess_SetAddressMask__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBProcess_SetAddressMask'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBProcess::SetAddressMask(lldb::AddressMaskType,lldb::addr_t,lldb::AddressMaskRange)\n"
    "    lldb::SBProcess::SetAddressMask(lldb::AddressMaskType,lldb::addr_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBProcess_SetAddressableBits__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::AddressMaskType arg2 ;
  uint32_t arg3 ;
  lldb::AddressMaskRange arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_SetAddressableBits" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_SetAddressableBits" "', argument " "2"" of type '" "lldb::AddressMaskType""'");
  } 
  arg2 = static_cast< lldb::AddressMaskType >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBProcess_SetAddressableBits" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBProcess_SetAddressableBits" "', argument " "4"" of type '" "lldb::AddressMaskRange""'");
  } 
  arg4 = static_cast< lldb::AddressMaskRange >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAddressableBits(arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_SetAddressableBits__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::AddressMaskType arg2 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_SetAddressableBits" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_SetAddressableBits" "', argument " "2"" of type '" "lldb::AddressMaskType""'");
  } 
  arg2 = static_cast< lldb::AddressMaskType >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBProcess_SetAddressableBits" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAddressableBits(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_SetAddressableBits(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBProcess_SetAddressableBits", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBProcess_SetAddressableBits__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBProcess_SetAddressableBits__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBProcess_SetAddressableBits'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBProcess::SetAddressableBits(lldb::AddressMaskType,uint32_t,lldb::AddressMaskRange)\n"
    "    lldb::SBProcess::SetAddressableBits(lldb::AddressMaskType,uint32_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBProcess_FixAddress__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::addr_t arg2 ;
  lldb::AddressMaskType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  lldb::addr_t result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_FixAddress" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_FixAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBProcess_FixAddress" "', argument " "3"" of type '" "lldb::AddressMaskType""'");
  } 
  arg3 = static_cast< lldb::AddressMaskType >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->FixAddress(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_FixAddress__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::addr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  lldb::addr_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_FixAddress" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_FixAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->FixAddress(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_FixAddress(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBProcess_FixAddress", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBProcess_FixAddress__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBProcess_FixAddress__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBProcess_FixAddress'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBProcess::FixAddress(lldb::addr_t,lldb::AddressMaskType)\n"
    "    lldb::SBProcess::FixAddress(lldb::addr_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBProcess_AllocateMemory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  size_t arg2 ;
  uint32_t arg3 ;
  lldb::SBError *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  lldb::addr_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_AllocateMemory", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_AllocateMemory" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_AllocateMemory" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBProcess_AllocateMemory" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBProcess_AllocateMemory" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_AllocateMemory" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBError * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->AllocateMemory(SWIG_STD_MOVE(arg2),arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_DeallocateMemory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::addr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_DeallocateMemory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_DeallocateMemory" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcess_DeallocateMemory" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->DeallocateMemory(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetScriptedImplementation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< lldb::SBScriptObject > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetScriptedImplementation" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetScriptedImplementation();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  {
    resultobj = nullptr;
    if (const void* impl = (&result)->GetPointer())
    resultobj = (PyObject*) impl;
    if (!resultobj) {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    } else {
      Py_INCREF(resultobj);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess_GetStatus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcess_GetStatus", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess_GetStatus" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBProcess_GetStatus" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcess_GetStatus" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->GetStatus(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcess___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcess___repr__" "', argument " "1"" of type '" "lldb::SBProcess *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBProcess___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBProcess, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBProcessInfo__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBProcessInfo *)new lldb::SBProcessInfo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBProcessInfo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBProcessInfo__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBProcessInfo *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBProcessInfo,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBProcessInfo" "', argument " "1"" of type '" "lldb::SBProcessInfo const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBProcessInfo" "', argument " "1"" of type '" "lldb::SBProcessInfo const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBProcessInfo *)new lldb::SBProcessInfo((lldb::SBProcessInfo const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBProcessInfo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBProcessInfo(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBProcessInfo", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBProcessInfo__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBProcessInfo, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBProcessInfo__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBProcessInfo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBProcessInfo::SBProcessInfo()\n"
    "    lldb::SBProcessInfo::SBProcessInfo(lldb::SBProcessInfo const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBProcessInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBProcessInfo" "', argument " "1"" of type '" "lldb::SBProcessInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfo___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfo___nonzero__" "', argument " "1"" of type '" "lldb::SBProcessInfo const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBProcessInfo const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfo_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfo_IsValid" "', argument " "1"" of type '" "lldb::SBProcessInfo const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBProcessInfo const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfo_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfo_GetName" "', argument " "1"" of type '" "lldb::SBProcessInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfo_GetExecutableFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfo_GetExecutableFile" "', argument " "1"" of type '" "lldb::SBProcessInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetExecutableFile();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfo_GetProcessID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::pid_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfo_GetProcessID" "', argument " "1"" of type '" "lldb::SBProcessInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::pid_t)(arg1)->GetProcessID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfo_GetUserID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfo_GetUserID" "', argument " "1"" of type '" "lldb::SBProcessInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetUserID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfo_GetGroupID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfo_GetGroupID" "', argument " "1"" of type '" "lldb::SBProcessInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetGroupID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfo_UserIDIsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfo_UserIDIsValid" "', argument " "1"" of type '" "lldb::SBProcessInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->UserIDIsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfo_GroupIDIsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfo_GroupIDIsValid" "', argument " "1"" of type '" "lldb::SBProcessInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GroupIDIsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfo_GetEffectiveUserID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfo_GetEffectiveUserID" "', argument " "1"" of type '" "lldb::SBProcessInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetEffectiveUserID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfo_GetEffectiveGroupID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfo_GetEffectiveGroupID" "', argument " "1"" of type '" "lldb::SBProcessInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetEffectiveGroupID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfo_EffectiveUserIDIsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfo_EffectiveUserIDIsValid" "', argument " "1"" of type '" "lldb::SBProcessInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->EffectiveUserIDIsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfo_EffectiveGroupIDIsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfo_EffectiveGroupIDIsValid" "', argument " "1"" of type '" "lldb::SBProcessInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->EffectiveGroupIDIsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfo_GetParentProcessID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::pid_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfo_GetParentProcessID" "', argument " "1"" of type '" "lldb::SBProcessInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::pid_t)(arg1)->GetParentProcessID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfo_GetTriple(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfo_GetTriple" "', argument " "1"" of type '" "lldb::SBProcessInfo *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetTriple();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBProcessInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBProcessInfo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBProcessInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBProcessInfoList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfoList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBProcessInfoList *)new lldb::SBProcessInfoList();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBProcessInfoList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBProcessInfoList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfoList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfoList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBProcessInfoList" "', argument " "1"" of type '" "lldb::SBProcessInfoList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfoList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBProcessInfoList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfoList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBProcessInfoList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBProcessInfoList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBProcessInfoList" "', argument " "1"" of type '" "lldb::SBProcessInfoList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBProcessInfoList" "', argument " "1"" of type '" "lldb::SBProcessInfoList const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfoList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBProcessInfoList *)new lldb::SBProcessInfoList((lldb::SBProcessInfoList const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBProcessInfoList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBProcessInfoList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBProcessInfoList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBProcessInfoList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBProcessInfoList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBProcessInfoList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBProcessInfoList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBProcessInfoList::SBProcessInfoList()\n"
    "    lldb::SBProcessInfoList::SBProcessInfoList(lldb::SBProcessInfoList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBProcessInfoList_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfoList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfoList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfoList_GetSize" "', argument " "1"" of type '" "lldb::SBProcessInfoList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfoList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBProcessInfoList const *)arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfoList_GetProcessInfoAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfoList *arg1 = 0 ;
  uint32_t arg2 ;
  lldb::SBProcessInfo *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBProcessInfoList_GetProcessInfoAtIndex", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfoList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfoList_GetProcessInfoAtIndex" "', argument " "1"" of type '" "lldb::SBProcessInfoList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfoList * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProcessInfoList_GetProcessInfoAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBProcessInfo,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBProcessInfoList_GetProcessInfoAtIndex" "', argument " "3"" of type '" "lldb::SBProcessInfo &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBProcessInfoList_GetProcessInfoAtIndex" "', argument " "3"" of type '" "lldb::SBProcessInfo &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBProcessInfo * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetProcessInfoAtIndex(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProcessInfoList_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProcessInfoList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProcessInfoList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProcessInfoList_Clear" "', argument " "1"" of type '" "lldb::SBProcessInfoList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProcessInfoList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBProcessInfoList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBProcessInfoList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBProcessInfoList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBProgress__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBDebugger *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBProgress *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBProgress" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBProgress" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBDebugger,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SBProgress" "', argument " "3"" of type '" "lldb::SBDebugger &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBProgress" "', argument " "3"" of type '" "lldb::SBDebugger &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBDebugger * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBProgress *)new lldb::SBProgress((char const *)arg1,(char const *)arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBProgress, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBProgress__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  uint64_t arg3 ;
  lldb::SBDebugger *arg4 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  lldb::SBProgress *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBProgress" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBProgress" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SBProgress" "', argument " "3"" of type '" "uint64_t""'");
  } 
  arg3 = static_cast< uint64_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBDebugger,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SBProgress" "', argument " "4"" of type '" "lldb::SBDebugger &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBProgress" "', argument " "4"" of type '" "lldb::SBDebugger &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBDebugger * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBProgress *)new lldb::SBProgress((char const *)arg1,(char const *)arg2,arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBProgress, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBProgress(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBProgress", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SBProgress__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SBProgress__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBProgress'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBProgress::SBProgress(char const *,char const *,lldb::SBDebugger &)\n"
    "    lldb::SBProgress::SBProgress(char const *,char const *,uint64_t,lldb::SBDebugger &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBProgress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProgress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProgress, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBProgress" "', argument " "1"" of type '" "lldb::SBProgress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProgress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProgress_Increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProgress *arg1 = 0 ;
  uint64_t arg2 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProgress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProgress_Increment" "', argument " "1"" of type '" "lldb::SBProgress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProgress * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProgress_Increment" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBProgress_Increment" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Increment(arg2,(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProgress_Increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBProgress *arg1 = 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProgress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProgress_Increment" "', argument " "1"" of type '" "lldb::SBProgress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProgress * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBProgress_Increment" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Increment(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBProgress_Increment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBProgress_Increment", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProgress, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBProgress_Increment__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBProgress, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBProgress_Increment__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBProgress_Increment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBProgress::Increment(uint64_t,char const *)\n"
    "    lldb::SBProgress::Increment(uint64_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBProgress_Finalize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBProgress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBProgress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBProgress_Finalize" "', argument " "1"" of type '" "lldb::SBProgress *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBProgress * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Finalize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBProgress_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBProgress, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBProgress_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBQueue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBQueue *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBQueue *)new lldb::SBQueue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBQueue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBQueue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBQueue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBQueue *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBQueue,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBQueue" "', argument " "1"" of type '" "lldb::SBQueue const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBQueue" "', argument " "1"" of type '" "lldb::SBQueue const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBQueue *)new lldb::SBQueue((lldb::SBQueue const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBQueue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBQueue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBQueue", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBQueue__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBQueue, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBQueue__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBQueue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBQueue::SBQueue()\n"
    "    lldb::SBQueue::SBQueue(lldb::SBQueue const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBQueue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBQueue" "', argument " "1"" of type '" "lldb::SBQueue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueue___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueue___nonzero__" "', argument " "1"" of type '" "lldb::SBQueue const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBQueue const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueue_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueue_IsValid" "', argument " "1"" of type '" "lldb::SBQueue const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBQueue const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueue_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueue_Clear" "', argument " "1"" of type '" "lldb::SBQueue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueue_GetProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBProcess result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueue_GetProcess" "', argument " "1"" of type '" "lldb::SBQueue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetProcess();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueue_GetQueueID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::queue_id_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueue_GetQueueID" "', argument " "1"" of type '" "lldb::SBQueue const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::queue_id_t)((lldb::SBQueue const *)arg1)->GetQueueID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueue_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueue_GetName" "', argument " "1"" of type '" "lldb::SBQueue const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBQueue const *)arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueue_GetIndexID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueue_GetIndexID" "', argument " "1"" of type '" "lldb::SBQueue const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBQueue const *)arg1)->GetIndexID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueue_GetNumThreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueue_GetNumThreads" "', argument " "1"" of type '" "lldb::SBQueue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumThreads();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueue_GetThreadAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueue *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBThread result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBQueue_GetThreadAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueue_GetThreadAtIndex" "', argument " "1"" of type '" "lldb::SBQueue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBQueue_GetThreadAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetThreadAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueue_GetNumPendingItems(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueue_GetNumPendingItems" "', argument " "1"" of type '" "lldb::SBQueue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumPendingItems();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueue_GetPendingItemAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueue *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBQueueItem result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBQueue_GetPendingItemAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueue_GetPendingItemAtIndex" "', argument " "1"" of type '" "lldb::SBQueue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBQueue_GetPendingItemAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetPendingItemAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBQueueItem(result)), SWIGTYPE_p_lldb__SBQueueItem, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueue_GetNumRunningItems(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueue_GetNumRunningItems" "', argument " "1"" of type '" "lldb::SBQueue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumRunningItems();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueue_GetKind(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::QueueKind result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueue_GetKind" "', argument " "1"" of type '" "lldb::SBQueue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::QueueKind)(arg1)->GetKind();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBQueue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBQueue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBQueue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBQueueItem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueueItem *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SBQueueItem", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBQueueItem *)new lldb::SBQueueItem();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBQueueItem, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBQueueItem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueueItem *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueueItem, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBQueueItem" "', argument " "1"" of type '" "lldb::SBQueueItem *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueueItem * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueueItem___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueueItem *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueueItem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueueItem___nonzero__" "', argument " "1"" of type '" "lldb::SBQueueItem const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueueItem * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBQueueItem const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueueItem_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueueItem *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueueItem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueueItem_IsValid" "', argument " "1"" of type '" "lldb::SBQueueItem const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueueItem * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBQueueItem const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueueItem_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueueItem *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueueItem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueueItem_Clear" "', argument " "1"" of type '" "lldb::SBQueueItem *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueueItem * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueueItem_GetKind(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueueItem *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::QueueItemKind result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueueItem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueueItem_GetKind" "', argument " "1"" of type '" "lldb::SBQueueItem const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueueItem * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::QueueItemKind)((lldb::SBQueueItem const *)arg1)->GetKind();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueueItem_SetKind(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueueItem *arg1 = 0 ;
  lldb::QueueItemKind arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBQueueItem_SetKind", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueueItem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueueItem_SetKind" "', argument " "1"" of type '" "lldb::SBQueueItem *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueueItem * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBQueueItem_SetKind" "', argument " "2"" of type '" "lldb::QueueItemKind""'");
  } 
  arg2 = static_cast< lldb::QueueItemKind >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetKind(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueueItem_GetAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueueItem *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueueItem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueueItem_GetAddress" "', argument " "1"" of type '" "lldb::SBQueueItem const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueueItem * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBQueueItem const *)arg1)->GetAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueueItem_SetAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueueItem *arg1 = 0 ;
  lldb::SBAddress arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBQueueItem_SetAddress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueueItem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueueItem_SetAddress" "', argument " "1"" of type '" "lldb::SBQueueItem *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueueItem * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBQueueItem_SetAddress" "', argument " "2"" of type '" "lldb::SBAddress""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBQueueItem_SetAddress" "', argument " "2"" of type '" "lldb::SBAddress""'");
    } else {
      lldb::SBAddress * temp = reinterpret_cast< lldb::SBAddress * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetAddress(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBQueueItem_GetExtendedBacktraceThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBQueueItem *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBThread result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBQueueItem_GetExtendedBacktraceThread", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBQueueItem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBQueueItem_GetExtendedBacktraceThread" "', argument " "1"" of type '" "lldb::SBQueueItem *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBQueueItem * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBQueueItem_GetExtendedBacktraceThread" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetExtendedBacktraceThread((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *SBQueueItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBQueueItem, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBQueueItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBReproducer_Capture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBReproducer_Capture" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBReproducer::Capture((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBReproducer_PassiveReplay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBReproducer_PassiveReplay" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBReproducer::PassiveReplay((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBReproducer_SetAutoGenerate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBReproducer_SetAutoGenerate" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBReproducer::SetAutoGenerate(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBReproducer_SetWorkingDirectory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBReproducer_SetWorkingDirectory" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb::SBReproducer::SetWorkingDirectory((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBReproducer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBReproducer *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SBReproducer", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBReproducer *)new lldb::SBReproducer();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBReproducer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBReproducer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBReproducer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBReproducer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBReproducer" "', argument " "1"" of type '" "lldb::SBReproducer *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBReproducer * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBReproducer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBReproducer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBReproducer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBScriptObject__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::ScriptObjectPtr arg1 = (lldb::ScriptObjectPtr)0 ;
  lldb::ScriptLanguage arg2 ;
  int val2 ;
  int ecode2 = 0 ;
  lldb::SBScriptObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    if (swig_obj[0] == Py_None) {
      arg1 = nullptr;
    } else {
      PythonObject obj(PyRefType::Borrowed, swig_obj[0]);
      if (!obj.IsValid()) {
        PyErr_SetString(PyExc_TypeError, "Script object is not valid");
        SWIG_fail;
      }
      
      auto lldb_module = PythonModule::Import("lldb");
      if (!lldb_module) {
        std::string err_msg = llvm::toString(lldb_module.takeError());
        PyErr_SetString(PyExc_TypeError, err_msg.c_str());
        SWIG_fail;
      }
      
      auto sb_structured_data_class = lldb_module.get().Get("SBStructuredData");
      if (!sb_structured_data_class) {
        std::string err_msg = llvm::toString(sb_structured_data_class.takeError());
        PyErr_SetString(PyExc_TypeError, err_msg.c_str());
        SWIG_fail;
      }
      
      if (obj.IsInstance(sb_structured_data_class.get())) {
        arg1 = obj.get();
      } else {
        auto type = obj.GetType();
        if (!type) {
          std::string err_msg = llvm::toString(type.takeError());
          PyErr_SetString(PyExc_TypeError, err_msg.c_str());
          SWIG_fail;
        }
        
        auto type_name = As<std::string>(type.get().GetAttribute("__name__"));
        if (!type_name) {
          std::string err_msg = llvm::toString(type_name.takeError());
          PyErr_SetString(PyExc_TypeError, err_msg.c_str());
          SWIG_fail;
        }
        
        if (llvm::StringRef(type_name.get()).starts_with("SB")) {
          std::string error_msg = "Input type is invalid: " + type_name.get();
          PyErr_SetString(PyExc_TypeError, error_msg.c_str());
          SWIG_fail;
        } else {
          arg1 = obj.get();
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBScriptObject" "', argument " "2"" of type '" "lldb::ScriptLanguage""'");
  } 
  arg2 = static_cast< lldb::ScriptLanguage >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBScriptObject *)new lldb::SBScriptObject(arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBScriptObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBScriptObject__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBScriptObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBScriptObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBScriptObject,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBScriptObject" "', argument " "1"" of type '" "lldb::SBScriptObject const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBScriptObject" "', argument " "1"" of type '" "lldb::SBScriptObject const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBScriptObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBScriptObject *)new lldb::SBScriptObject((lldb::SBScriptObject const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBScriptObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBScriptObject(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBScriptObject", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBScriptObject, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBScriptObject__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      PythonObject obj(PyRefType::Borrowed, argv[0]);
      if (!obj.IsValid()) {
        PyErr_Clear();
        _v = 0;
      } else {
        _v = 1;
      }
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SBScriptObject__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBScriptObject'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBScriptObject::SBScriptObject(lldb::ScriptObjectPtr const,lldb::ScriptLanguage)\n"
    "    lldb::SBScriptObject::SBScriptObject(lldb::SBScriptObject const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBScriptObject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBScriptObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBScriptObject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBScriptObject" "', argument " "1"" of type '" "lldb::SBScriptObject *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBScriptObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBScriptObject___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBScriptObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBScriptObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBScriptObject___nonzero__" "', argument " "1"" of type '" "lldb::SBScriptObject const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBScriptObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBScriptObject const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBScriptObject___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBScriptObject *arg1 = 0 ;
  lldb::SBScriptObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBScriptObject___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBScriptObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBScriptObject___ne__" "', argument " "1"" of type '" "lldb::SBScriptObject const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBScriptObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBScriptObject,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBScriptObject___ne__" "', argument " "2"" of type '" "lldb::SBScriptObject const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBScriptObject___ne__" "', argument " "2"" of type '" "lldb::SBScriptObject const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBScriptObject * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBScriptObject const *)arg1)->operator !=((lldb::SBScriptObject const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBScriptObject_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBScriptObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBScriptObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBScriptObject_IsValid" "', argument " "1"" of type '" "lldb::SBScriptObject const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBScriptObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBScriptObject const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBScriptObject_GetPointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBScriptObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::ScriptObjectPtr result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBScriptObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBScriptObject_GetPointer" "', argument " "1"" of type '" "lldb::SBScriptObject const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBScriptObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ScriptObjectPtr)((lldb::SBScriptObject const *)arg1)->GetPointer();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  {
    resultobj = (PyObject*) result;
    if (!resultobj)
    resultobj = Py_None;
    Py_INCREF(resultobj);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBScriptObject_GetLanguage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBScriptObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::ScriptLanguage result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBScriptObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBScriptObject_GetLanguage" "', argument " "1"" of type '" "lldb::SBScriptObject const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBScriptObject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ScriptLanguage)((lldb::SBScriptObject const *)arg1)->GetLanguage();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBScriptObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBScriptObject, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBScriptObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBSection *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBSection *)new lldb::SBSection();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBSection *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBSection,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBSection" "', argument " "1"" of type '" "lldb::SBSection const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBSection" "', argument " "1"" of type '" "lldb::SBSection const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBSection *)new lldb::SBSection((lldb::SBSection const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBSection", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBSection__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBSection__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBSection::SBSection()\n"
    "    lldb::SBSection::SBSection(lldb::SBSection const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBSection" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection___nonzero__" "', argument " "1"" of type '" "lldb::SBSection const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBSection const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_IsValid" "', argument " "1"" of type '" "lldb::SBSection const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBSection const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_GetName" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_GetParent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBSection result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_GetParent" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetParent();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSection(result)), SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_FindSubSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBSection result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSection_FindSubSection", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_FindSubSection" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSection_FindSubSection" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindSubSection((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSection(result)), SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_GetNumSubSections(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_GetNumSubSections" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetNumSubSections();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_GetSubSectionAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBSection result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSection_GetSubSectionAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_GetSubSectionAtIndex" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBSection_GetSubSectionAtIndex" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSubSectionAtIndex(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSection(result)), SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_GetFileAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_GetFileAddress" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->GetFileAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_GetLoadAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  lldb::SBTarget *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::addr_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSection_GetLoadAddress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_GetLoadAddress" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSection_GetLoadAddress" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSection_GetLoadAddress" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->GetLoadAddress(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_GetByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_GetByteSize" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->GetByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_GetFileOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_GetFileOffset" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetFileOffset();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_GetFileByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_GetFileByteSize" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetFileByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_GetSectionData__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBData result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_GetSectionData" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSectionData();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBData(result)), SWIGTYPE_p_lldb__SBData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_GetSectionData__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  uint64_t arg2 ;
  uint64_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  lldb::SBData result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_GetSectionData" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBSection_GetSectionData" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBSection_GetSectionData" "', argument " "3"" of type '" "uint64_t""'");
  } 
  arg3 = static_cast< uint64_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSectionData(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBData(result)), SWIGTYPE_p_lldb__SBData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_GetSectionData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBSection_GetSectionData", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBSection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBSection_GetSectionData__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBSection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBSection_GetSectionData__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBSection_GetSectionData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBSection::GetSectionData()\n"
    "    lldb::SBSection::GetSectionData(uint64_t,uint64_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBSection_GetSectionType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SectionType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_GetSectionType" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SectionType)(arg1)->GetSectionType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_GetPermissions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_GetPermissions" "', argument " "1"" of type '" "lldb::SBSection const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBSection const *)arg1)->GetPermissions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_GetTargetByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_GetTargetByteSize" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetTargetByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection_GetAlignment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_GetAlignment" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetAlignment();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  lldb::SBSection *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSection___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection___eq__" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBSection,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSection___eq__" "', argument " "2"" of type '" "lldb::SBSection const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSection___eq__" "', argument " "2"" of type '" "lldb::SBSection const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBSection * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator ==((lldb::SBSection const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBSection___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  lldb::SBSection *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSection___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection___ne__" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBSection,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSection___ne__" "', argument " "2"" of type '" "lldb::SBSection const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSection___ne__" "', argument " "2"" of type '" "lldb::SBSection const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBSection * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator !=((lldb::SBSection const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBSection_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSection_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection_GetDescription" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSection_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSection_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSection___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSection___repr__" "', argument " "1"" of type '" "lldb::SBSection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBSection___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBSection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBSourceManager__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBDebugger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBSourceManager *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBDebugger,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBSourceManager" "', argument " "1"" of type '" "lldb::SBDebugger const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBSourceManager" "', argument " "1"" of type '" "lldb::SBDebugger const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBDebugger * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBSourceManager *)new lldb::SBSourceManager((lldb::SBDebugger const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBSourceManager, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBSourceManager__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBSourceManager *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBSourceManager" "', argument " "1"" of type '" "lldb::SBTarget const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBSourceManager" "', argument " "1"" of type '" "lldb::SBTarget const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBSourceManager *)new lldb::SBSourceManager((lldb::SBTarget const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBSourceManager, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBSourceManager__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBSourceManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBSourceManager *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBSourceManager,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBSourceManager" "', argument " "1"" of type '" "lldb::SBSourceManager const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBSourceManager" "', argument " "1"" of type '" "lldb::SBSourceManager const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSourceManager * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBSourceManager *)new lldb::SBSourceManager((lldb::SBSourceManager const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBSourceManager, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBSourceManager(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBSourceManager", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBSourceManager__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBSourceManager__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBSourceManager, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBSourceManager__SWIG_2(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBSourceManager'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBSourceManager::SBSourceManager(lldb::SBDebugger const &)\n"
    "    lldb::SBSourceManager::SBSourceManager(lldb::SBTarget const &)\n"
    "    lldb::SBSourceManager::SBSourceManager(lldb::SBSourceManager const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBSourceManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSourceManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSourceManager, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBSourceManager" "', argument " "1"" of type '" "lldb::SBSourceManager *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSourceManager * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSourceManager_DisplaySourceLinesWithLineNumbers(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSourceManager *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  uint32_t arg5 ;
  char *arg6 = 0 ;
  lldb::SBStream *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject *swig_obj[7] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSourceManager_DisplaySourceLinesWithLineNumbers", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbers" "', argument " "1"" of type '" "lldb::SBSourceManager *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSourceManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbers" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbers" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbers" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbers" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbers" "', argument " "5"" of type '" "uint32_t""'");
  } 
  arg5 = static_cast< uint32_t >(val5);
  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbers" "', argument " "6"" of type '" "char const *""'");
  }
  arg6 = reinterpret_cast< char * >(buf6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbers" "', argument " "7"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbers" "', argument " "7"" of type '" "lldb::SBStream &""'"); 
  }
  arg7 = reinterpret_cast< lldb::SBStream * >(argp7);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->DisplaySourceLinesWithLineNumbers((lldb::SBFileSpec const &)*arg2,arg3,arg4,arg5,(char const *)arg6,*arg7);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  return resultobj;
fail:
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSourceManager *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  uint32_t arg5 ;
  uint32_t arg6 ;
  char *arg7 = 0 ;
  lldb::SBStream *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  int res7 ;
  char *buf7 = 0 ;
  int alloc7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject *swig_obj[8] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn", 8, 8, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn" "', argument " "1"" of type '" "lldb::SBSourceManager *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSourceManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn" "', argument " "5"" of type '" "uint32_t""'");
  } 
  arg5 = static_cast< uint32_t >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn" "', argument " "6"" of type '" "uint32_t""'");
  } 
  arg6 = static_cast< uint32_t >(val6);
  res7 = SWIG_AsCharPtrAndSize(swig_obj[6], &buf7, NULL, &alloc7);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn" "', argument " "7"" of type '" "char const *""'");
  }
  arg7 = reinterpret_cast< char * >(buf7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn" "', argument " "8"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn" "', argument " "8"" of type '" "lldb::SBStream &""'"); 
  }
  arg8 = reinterpret_cast< lldb::SBStream * >(argp8);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->DisplaySourceLinesWithLineNumbersAndColumn((lldb::SBFileSpec const &)*arg2,arg3,arg4,arg5,arg6,(char const *)arg7,*arg8);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
  return resultobj;
fail:
  if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
  return NULL;
}


SWIGINTERN PyObject *SBSourceManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBSourceManager, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBSourceManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBStatisticsOptions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBStatisticsOptions *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBStatisticsOptions *)new lldb::SBStatisticsOptions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBStatisticsOptions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBStatisticsOptions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStatisticsOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBStatisticsOptions *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBStatisticsOptions,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBStatisticsOptions" "', argument " "1"" of type '" "lldb::SBStatisticsOptions const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBStatisticsOptions" "', argument " "1"" of type '" "lldb::SBStatisticsOptions const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStatisticsOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBStatisticsOptions *)new lldb::SBStatisticsOptions((lldb::SBStatisticsOptions const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBStatisticsOptions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBStatisticsOptions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBStatisticsOptions", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBStatisticsOptions__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBStatisticsOptions, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBStatisticsOptions__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBStatisticsOptions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBStatisticsOptions::SBStatisticsOptions()\n"
    "    lldb::SBStatisticsOptions::SBStatisticsOptions(lldb::SBStatisticsOptions const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBStatisticsOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStatisticsOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStatisticsOptions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBStatisticsOptions" "', argument " "1"" of type '" "lldb::SBStatisticsOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStatisticsOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStatisticsOptions_SetSummaryOnly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStatisticsOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStatisticsOptions_SetSummaryOnly", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStatisticsOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStatisticsOptions_SetSummaryOnly" "', argument " "1"" of type '" "lldb::SBStatisticsOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStatisticsOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStatisticsOptions_SetSummaryOnly" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetSummaryOnly(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStatisticsOptions_GetSummaryOnly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStatisticsOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStatisticsOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStatisticsOptions_GetSummaryOnly" "', argument " "1"" of type '" "lldb::SBStatisticsOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStatisticsOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetSummaryOnly();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStatisticsOptions_SetIncludeTargets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStatisticsOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStatisticsOptions_SetIncludeTargets", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStatisticsOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStatisticsOptions_SetIncludeTargets" "', argument " "1"" of type '" "lldb::SBStatisticsOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStatisticsOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStatisticsOptions_SetIncludeTargets" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetIncludeTargets(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStatisticsOptions_GetIncludeTargets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStatisticsOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStatisticsOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStatisticsOptions_GetIncludeTargets" "', argument " "1"" of type '" "lldb::SBStatisticsOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStatisticsOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBStatisticsOptions const *)arg1)->GetIncludeTargets();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStatisticsOptions_SetIncludeModules(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStatisticsOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStatisticsOptions_SetIncludeModules", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStatisticsOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStatisticsOptions_SetIncludeModules" "', argument " "1"" of type '" "lldb::SBStatisticsOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStatisticsOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStatisticsOptions_SetIncludeModules" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetIncludeModules(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStatisticsOptions_GetIncludeModules(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStatisticsOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStatisticsOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStatisticsOptions_GetIncludeModules" "', argument " "1"" of type '" "lldb::SBStatisticsOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStatisticsOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBStatisticsOptions const *)arg1)->GetIncludeModules();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStatisticsOptions_SetIncludeTranscript(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStatisticsOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStatisticsOptions_SetIncludeTranscript", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStatisticsOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStatisticsOptions_SetIncludeTranscript" "', argument " "1"" of type '" "lldb::SBStatisticsOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStatisticsOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStatisticsOptions_SetIncludeTranscript" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetIncludeTranscript(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStatisticsOptions_GetIncludeTranscript(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStatisticsOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStatisticsOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStatisticsOptions_GetIncludeTranscript" "', argument " "1"" of type '" "lldb::SBStatisticsOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStatisticsOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBStatisticsOptions const *)arg1)->GetIncludeTranscript();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStatisticsOptions_SetReportAllAvailableDebugInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStatisticsOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStatisticsOptions_SetReportAllAvailableDebugInfo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStatisticsOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStatisticsOptions_SetReportAllAvailableDebugInfo" "', argument " "1"" of type '" "lldb::SBStatisticsOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStatisticsOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStatisticsOptions_SetReportAllAvailableDebugInfo" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetReportAllAvailableDebugInfo(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStatisticsOptions_GetReportAllAvailableDebugInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStatisticsOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStatisticsOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStatisticsOptions_GetReportAllAvailableDebugInfo" "', argument " "1"" of type '" "lldb::SBStatisticsOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStatisticsOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetReportAllAvailableDebugInfo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBStatisticsOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBStatisticsOptions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBStatisticsOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBStream(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStream *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SBStream", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBStream *)new lldb::SBStream();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBStream(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBStream" "', argument " "1"" of type '" "lldb::SBStream *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStream * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStream___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStream___nonzero__" "', argument " "1"" of type '" "lldb::SBStream const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStream * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBStream const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStream_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStream_IsValid" "', argument " "1"" of type '" "lldb::SBStream const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStream * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBStream const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStream_GetData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStream_GetData" "', argument " "1"" of type '" "lldb::SBStream *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStream * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetData();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStream_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStream_GetSize" "', argument " "1"" of type '" "lldb::SBStream *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStream * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStream_Print(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStream *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStream_Print", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStream_Print" "', argument " "1"" of type '" "lldb::SBStream *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStream * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBStream_Print" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Print((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStream_RedirectToFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStream *arg1 = 0 ;
  char *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStream_RedirectToFile" "', argument " "1"" of type '" "lldb::SBStream *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStream * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBStream_RedirectToFile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBStream_RedirectToFile" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->RedirectToFile((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStream_RedirectToFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStream *arg1 = 0 ;
  lldb::SBFile arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStream_RedirectToFile" "', argument " "1"" of type '" "lldb::SBStream *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStream * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFile,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBStream_RedirectToFile" "', argument " "2"" of type '" "lldb::SBFile""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBStream_RedirectToFile" "', argument " "2"" of type '" "lldb::SBFile""'");
    } else {
      lldb::SBFile * temp = reinterpret_cast< lldb::SBFile * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->RedirectToFile(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStream_RedirectToFile__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStream *arg1 = 0 ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStream_RedirectToFile" "', argument " "1"" of type '" "lldb::SBStream *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStream * >(argp1);
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[1]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp = unwrapOrSetPythonException(py_file.ConvertToFile());
    if (!sp)
    SWIG_fail;
    arg2 = sp;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->RedirectToFile(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStream_RedirectToFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBStream_RedirectToFile", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBStream_RedirectToFile__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        if (PythonFile::Check(argv[1])) {
          _v = 1;
        } else {
          PyErr_Clear();
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SBStream_RedirectToFile__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBStream_RedirectToFile__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBStream_RedirectToFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBStream::RedirectToFile(char const *,bool)\n"
    "    lldb::SBStream::RedirectToFile(lldb::SBFile)\n"
    "    lldb::SBStream::RedirectToFile(lldb::FileSP)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBStream_RedirectToFileDescriptor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStream *arg1 = 0 ;
  int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStream_RedirectToFileDescriptor", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStream_RedirectToFileDescriptor" "', argument " "1"" of type '" "lldb::SBStream *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStream * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStream_RedirectToFileDescriptor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBStream_RedirectToFileDescriptor" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->RedirectToFileDescriptor(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStream_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStream_Clear" "', argument " "1"" of type '" "lldb::SBStream *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStream * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStream_RedirectToFileHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStream *arg1 = 0 ;
  SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStream_RedirectToFileHandle", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStream_RedirectToFileHandle" "', argument " "1"" of type '" "lldb::SBStream *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStream * >(argp1);
  {
    PythonFile py_file(PyRefType::Borrowed, swig_obj[1]);
    if (!py_file) {
      PyErr_SetString(PyExc_TypeError, "not a file");
      SWIG_fail;
    }
    auto sp = unwrapOrSetPythonException(py_file.ConvertToFile());
    if (!sp)
    SWIG_fail;
    arg2 = sp;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBStream_RedirectToFileHandle" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb_SBStream_RedirectToFileHandle(arg1,SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStream_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStream *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStream_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStream_write" "', argument " "1"" of type '" "lldb::SBStream *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStream * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBStream_write" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb_SBStream_write(arg1,(char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStream_flush(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStream_flush" "', argument " "1"" of type '" "lldb::SBStream *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStream * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    lldb_SBStream_flush(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBStream, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBStringList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBStringList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBStringList *)new lldb::SBStringList();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBStringList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStringList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBStringList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBStringList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBStringList" "', argument " "1"" of type '" "lldb::SBStringList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBStringList" "', argument " "1"" of type '" "lldb::SBStringList const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStringList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBStringList *)new lldb::SBStringList((lldb::SBStringList const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBStringList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBStringList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBStringList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBStringList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBStringList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBStringList::SBStringList()\n"
    "    lldb::SBStringList::SBStringList(lldb::SBStringList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBStringList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStringList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBStringList" "', argument " "1"" of type '" "lldb::SBStringList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStringList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStringList___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStringList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStringList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStringList___nonzero__" "', argument " "1"" of type '" "lldb::SBStringList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStringList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBStringList const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStringList_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStringList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStringList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStringList_IsValid" "', argument " "1"" of type '" "lldb::SBStringList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStringList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBStringList const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStringList_AppendString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStringList *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStringList_AppendString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStringList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStringList_AppendString" "', argument " "1"" of type '" "lldb::SBStringList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStringList * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBStringList_AppendString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->AppendString((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStringList_AppendList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStringList *arg1 = 0 ;
  char **arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStringList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStringList_AppendList" "', argument " "1"" of type '" "lldb::SBStringList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStringList * >(argp1);
  {
    /* Check if is a list  */
    if (PythonList::Check(swig_obj[1])) {
      PythonList list(PyRefType::Borrowed, swig_obj[1]);
      int size = list.GetSize();
      int i = 0;
      arg2 = (char **)malloc((size + 1) * sizeof(char *));
      for (i = 0; i < size; i++) {
        PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
        if (!py_str.IsAllocated()) {
          PyErr_SetString(PyExc_TypeError, "list must contain strings");
          SWIG_fail;
        }
        
        arg2[i] = const_cast<char *>(py_str.GetString().data());
      }
      arg2[i] = 0;
    } else if (swig_obj[1] == Py_None) {
      arg2 = NULL;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBStringList_AppendList" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->AppendList((char const **)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    free((char *) arg2);
  }
  return resultobj;
fail:
  {
    free((char *) arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStringList_AppendList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStringList *arg1 = 0 ;
  lldb::SBStringList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStringList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStringList_AppendList" "', argument " "1"" of type '" "lldb::SBStringList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStringList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStringList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBStringList_AppendList" "', argument " "2"" of type '" "lldb::SBStringList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBStringList_AppendList" "', argument " "2"" of type '" "lldb::SBStringList const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->AppendList((lldb::SBStringList const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStringList_AppendList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBStringList_AppendList", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStringList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBStringList_AppendList__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStringList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* Check if is a list  */
        _v = 1;
        if (PythonList::Check(argv[1])) {
          PythonList list(PyRefType::Borrowed, argv[1]);
          int size = list.GetSize();
          int i = 0;
          for (i = 0; i < size; i++) {
            PythonString s = list.GetItemAtIndex(i).AsType<PythonString>();
            if (!s.IsAllocated()) {
              _v = 0;
            }
          }
        } else {
          _v = ((argv[1] == Py_None) ? 1 : 0);
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBStringList_AppendList__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBStringList_AppendList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBStringList::AppendList(char const **,int)\n"
    "    lldb::SBStringList::AppendList(lldb::SBStringList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBStringList_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStringList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStringList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStringList_GetSize" "', argument " "1"" of type '" "lldb::SBStringList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStringList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBStringList const *)arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStringList_GetStringAtIndex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStringList *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStringList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStringList_GetStringAtIndex" "', argument " "1"" of type '" "lldb::SBStringList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStringList * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStringList_GetStringAtIndex" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetStringAtIndex(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStringList_GetStringAtIndex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStringList *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStringList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStringList_GetStringAtIndex" "', argument " "1"" of type '" "lldb::SBStringList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStringList * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStringList_GetStringAtIndex" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBStringList const *)arg1)->GetStringAtIndex(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStringList_GetStringAtIndex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBStringList_GetStringAtIndex", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStringList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBStringList_GetStringAtIndex__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStringList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBStringList_GetStringAtIndex__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBStringList_GetStringAtIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBStringList::GetStringAtIndex(size_t)\n"
    "    lldb::SBStringList::GetStringAtIndex(size_t) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBStringList_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStringList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStringList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStringList_Clear" "', argument " "1"" of type '" "lldb::SBStringList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStringList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBStringList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBStringList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBStringList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBStructuredData__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBStructuredData *)new lldb::SBStructuredData();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBStructuredData__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBStructuredData *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBStructuredData,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBStructuredData" "', argument " "1"" of type '" "lldb::SBStructuredData const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBStructuredData" "', argument " "1"" of type '" "lldb::SBStructuredData const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBStructuredData *)new lldb::SBStructuredData((lldb::SBStructuredData const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBStructuredData__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwigValueWrapper< lldb::SBScriptObject > arg1 ;
  lldb::SBDebugger *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  lldb::SBStructuredData *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBScriptObject,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBStructuredData" "', argument " "1"" of type '" "lldb::SBScriptObject const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBStructuredData" "', argument " "1"" of type '" "lldb::SBScriptObject const""'");
    } else {
      lldb::SBScriptObject * temp = reinterpret_cast< lldb::SBScriptObject * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBDebugger,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBStructuredData" "', argument " "2"" of type '" "lldb::SBDebugger const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBStructuredData" "', argument " "2"" of type '" "lldb::SBDebugger const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBDebugger * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBStructuredData *)new lldb::SBStructuredData(SWIG_STD_MOVE(arg1),(lldb::SBDebugger const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBStructuredData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBStructuredData", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBStructuredData__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBStructuredData__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBScriptObject, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SBStructuredData__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBStructuredData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBStructuredData::SBStructuredData()\n"
    "    lldb::SBStructuredData::SBStructuredData(lldb::SBStructuredData const &)\n"
    "    lldb::SBStructuredData::SBStructuredData(lldb::SBScriptObject const,lldb::SBDebugger const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBStructuredData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBStructuredData" "', argument " "1"" of type '" "lldb::SBStructuredData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData___nonzero__" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBStructuredData const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_IsValid" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBStructuredData const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_SetFromJSON__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_SetFromJSON" "', argument " "1"" of type '" "lldb::SBStructuredData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBStructuredData_SetFromJSON" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBStructuredData_SetFromJSON" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetFromJSON(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_SetFromJSON__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_SetFromJSON" "', argument " "1"" of type '" "lldb::SBStructuredData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBStructuredData_SetFromJSON" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetFromJSON((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_SetFromJSON(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBStructuredData_SetFromJSON", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStructuredData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBStructuredData_SetFromJSON__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStructuredData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBStructuredData_SetFromJSON__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBStructuredData_SetFromJSON'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBStructuredData::SetFromJSON(lldb::SBStream &)\n"
    "    lldb::SBStructuredData::SetFromJSON(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_Clear" "', argument " "1"" of type '" "lldb::SBStructuredData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetAsJSON(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStructuredData_GetAsJSON", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetAsJSON" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBStructuredData_GetAsJSON" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBStructuredData_GetAsJSON" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBStructuredData const *)arg1)->GetAsJSON(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStructuredData_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetDescription" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBStructuredData_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBStructuredData_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBStructuredData const *)arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::StructuredDataType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetType" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::StructuredDataType)((lldb::SBStructuredData const *)arg1)->GetType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetSize" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBStructuredData const *)arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetKeys(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  lldb::SBStringList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStructuredData_GetKeys", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetKeys" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBStructuredData_GetKeys" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBStructuredData_GetKeys" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBStructuredData const *)arg1)->GetKeys(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetValueForKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStructuredData_GetValueForKey", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetValueForKey" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBStructuredData_GetValueForKey" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBStructuredData const *)arg1)->GetValueForKey((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetItemAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBStructuredData result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStructuredData_GetItemAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetItemAtIndex" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStructuredData_GetItemAtIndex" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBStructuredData const *)arg1)->GetItemAtIndex(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetUnsignedIntegerValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  uint64_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetUnsignedIntegerValue" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStructuredData_GetUnsignedIntegerValue" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)((lldb::SBStructuredData const *)arg1)->GetUnsignedIntegerValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetUnsignedIntegerValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint64_t result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetUnsignedIntegerValue" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)((lldb::SBStructuredData const *)arg1)->GetUnsignedIntegerValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetUnsignedIntegerValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBStructuredData_GetUnsignedIntegerValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStructuredData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBStructuredData_GetUnsignedIntegerValue__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStructuredData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBStructuredData_GetUnsignedIntegerValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBStructuredData_GetUnsignedIntegerValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBStructuredData::GetUnsignedIntegerValue(uint64_t) const\n"
    "    lldb::SBStructuredData::GetUnsignedIntegerValue() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetSignedIntegerValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  int64_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetSignedIntegerValue" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStructuredData_GetSignedIntegerValue" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = static_cast< int64_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int64_t)((lldb::SBStructuredData const *)arg1)->GetSignedIntegerValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetSignedIntegerValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int64_t result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetSignedIntegerValue" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int64_t)((lldb::SBStructuredData const *)arg1)->GetSignedIntegerValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetSignedIntegerValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBStructuredData_GetSignedIntegerValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStructuredData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBStructuredData_GetSignedIntegerValue__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStructuredData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBStructuredData_GetSignedIntegerValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBStructuredData_GetSignedIntegerValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBStructuredData::GetSignedIntegerValue(int64_t) const\n"
    "    lldb::SBStructuredData::GetSignedIntegerValue() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetIntegerValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  uint64_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetIntegerValue" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStructuredData_GetIntegerValue" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)((lldb::SBStructuredData const *)arg1)->GetIntegerValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetIntegerValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint64_t result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetIntegerValue" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)((lldb::SBStructuredData const *)arg1)->GetIntegerValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetIntegerValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBStructuredData_GetIntegerValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStructuredData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBStructuredData_GetIntegerValue__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStructuredData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBStructuredData_GetIntegerValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBStructuredData_GetIntegerValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBStructuredData::GetIntegerValue(uint64_t) const\n"
    "    lldb::SBStructuredData::GetIntegerValue() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetFloatValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetFloatValue" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStructuredData_GetFloatValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (double)((lldb::SBStructuredData const *)arg1)->GetFloatValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetFloatValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetFloatValue" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (double)((lldb::SBStructuredData const *)arg1)->GetFloatValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetFloatValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBStructuredData_GetFloatValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStructuredData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBStructuredData_GetFloatValue__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStructuredData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBStructuredData_GetFloatValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBStructuredData_GetFloatValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBStructuredData::GetFloatValue(double) const\n"
    "    lldb::SBStructuredData::GetFloatValue() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetBooleanValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetBooleanValue" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStructuredData_GetBooleanValue" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBStructuredData const *)arg1)->GetBooleanValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetBooleanValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetBooleanValue" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBStructuredData const *)arg1)->GetBooleanValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetBooleanValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBStructuredData_GetBooleanValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStructuredData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBStructuredData_GetBooleanValue__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBStructuredData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBStructuredData_GetBooleanValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBStructuredData_GetBooleanValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBStructuredData::GetBooleanValue(bool) const\n"
    "    lldb::SBStructuredData::GetBooleanValue() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetStringValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  char *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStructuredData_GetStringValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetStringValue" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  {
    if (!PyLong_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError, "Expecting an integer");
      SWIG_fail;
    }
    arg3 = PyLong_AsLong(swig_obj[1]);
    if (arg3 <= 0) {
      PyErr_SetString(PyExc_ValueError, "Positive integer expected");
      SWIG_fail;
    }
    arg2 = (char *)malloc(arg3);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBStructuredData const *)arg1)->GetStringValue(arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  {
    Py_XDECREF(resultobj); /* Blow away any previous result */
    if (result == 0) {
      PythonString string("");
      resultobj = string.release();
      Py_INCREF(resultobj);
    } else {
      llvm::StringRef ref(static_cast<const char *>(arg2), result);
      PythonString string(ref);
      resultobj = string.release();
    }
    free(arg2);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_GetGenericValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< lldb::SBScriptObject > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_GetGenericValue" "', argument " "1"" of type '" "lldb::SBStructuredData const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBStructuredData const *)arg1)->GetGenericValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  {
    resultobj = nullptr;
    if (const void* impl = (&result)->GetPointer())
    resultobj = (PyObject*) impl;
    if (!resultobj) {
      resultobj = Py_None;
      Py_INCREF(Py_None);
    } else {
      Py_INCREF(resultobj);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_SetValueForKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBStructuredData *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStructuredData_SetValueForKey", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_SetValueForKey" "', argument " "1"" of type '" "lldb::SBStructuredData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBStructuredData_SetValueForKey" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStructuredData,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBStructuredData_SetValueForKey" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBStructuredData_SetValueForKey" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBStructuredData * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetValueForKey((char const *)arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_SetUnsignedIntegerValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStructuredData_SetUnsignedIntegerValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_SetUnsignedIntegerValue" "', argument " "1"" of type '" "lldb::SBStructuredData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStructuredData_SetUnsignedIntegerValue" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetUnsignedIntegerValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_SetSignedIntegerValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStructuredData_SetSignedIntegerValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_SetSignedIntegerValue" "', argument " "1"" of type '" "lldb::SBStructuredData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStructuredData_SetSignedIntegerValue" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = static_cast< int64_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetSignedIntegerValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_SetFloatValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStructuredData_SetFloatValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_SetFloatValue" "', argument " "1"" of type '" "lldb::SBStructuredData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStructuredData_SetFloatValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetFloatValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_SetBooleanValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStructuredData_SetBooleanValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_SetBooleanValue" "', argument " "1"" of type '" "lldb::SBStructuredData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBStructuredData_SetBooleanValue" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetBooleanValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_SetStringValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStructuredData_SetStringValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_SetStringValue" "', argument " "1"" of type '" "lldb::SBStructuredData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBStructuredData_SetStringValue" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetStringValue((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData_SetGenericValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  SwigValueWrapper< lldb::SBScriptObject > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBStructuredData_SetGenericValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData_SetGenericValue" "', argument " "1"" of type '" "lldb::SBStructuredData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBScriptObject,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBStructuredData_SetGenericValue" "', argument " "2"" of type '" "lldb::SBScriptObject""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBStructuredData_SetGenericValue" "', argument " "2"" of type '" "lldb::SBScriptObject""'");
    } else {
      lldb::SBScriptObject * temp = reinterpret_cast< lldb::SBScriptObject * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetGenericValue(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBStructuredData___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBStructuredData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBStructuredData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBStructuredData___repr__" "', argument " "1"" of type '" "lldb::SBStructuredData *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBStructuredData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBStructuredData___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBStructuredData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBStructuredData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBStructuredData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBSymbol__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBSymbol *)new lldb::SBSymbol();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBSymbol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBSymbol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBSymbol" "', argument " "1"" of type '" "lldb::SBSymbol *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBSymbol__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBSymbol *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBSymbol,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBSymbol" "', argument " "1"" of type '" "lldb::SBSymbol const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBSymbol" "', argument " "1"" of type '" "lldb::SBSymbol const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBSymbol *)new lldb::SBSymbol((lldb::SBSymbol const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBSymbol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBSymbol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBSymbol", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBSymbol__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBSymbol, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBSymbol__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBSymbol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBSymbol::SBSymbol()\n"
    "    lldb::SBSymbol::SBSymbol(lldb::SBSymbol const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBSymbol___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol___nonzero__" "', argument " "1"" of type '" "lldb::SBSymbol const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBSymbol const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_IsValid" "', argument " "1"" of type '" "lldb::SBSymbol const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBSymbol const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_GetName" "', argument " "1"" of type '" "lldb::SBSymbol const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBSymbol const *)arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetDisplayName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_GetDisplayName" "', argument " "1"" of type '" "lldb::SBSymbol const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBSymbol const *)arg1)->GetDisplayName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetMangledName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_GetMangledName" "', argument " "1"" of type '" "lldb::SBSymbol const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBSymbol const *)arg1)->GetMangledName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetBaseName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_GetBaseName" "', argument " "1"" of type '" "lldb::SBSymbol const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBSymbol const *)arg1)->GetBaseName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetInstructions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  lldb::SBTarget arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  lldb::SBInstructionList result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_GetInstructions" "', argument " "1"" of type '" "lldb::SBSymbol *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSymbol_GetInstructions" "', argument " "2"" of type '" "lldb::SBTarget""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbol_GetInstructions" "', argument " "2"" of type '" "lldb::SBTarget""'");
    } else {
      lldb::SBTarget * temp = reinterpret_cast< lldb::SBTarget * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetInstructions(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBInstructionList(result)), SWIGTYPE_p_lldb__SBInstructionList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetInstructions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  lldb::SBTarget arg2 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  lldb::SBInstructionList result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_GetInstructions" "', argument " "1"" of type '" "lldb::SBSymbol *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSymbol_GetInstructions" "', argument " "2"" of type '" "lldb::SBTarget""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbol_GetInstructions" "', argument " "2"" of type '" "lldb::SBTarget""'");
    } else {
      lldb::SBTarget * temp = reinterpret_cast< lldb::SBTarget * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBSymbol_GetInstructions" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetInstructions(SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBInstructionList(result)), SWIGTYPE_p_lldb__SBInstructionList, SWIG_POINTER_OWN |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetInstructions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBSymbol_GetInstructions", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBSymbol, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBSymbol_GetInstructions__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBSymbol, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBSymbol_GetInstructions__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBSymbol_GetInstructions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBSymbol::GetInstructions(lldb::SBTarget)\n"
    "    lldb::SBSymbol::GetInstructions(lldb::SBTarget,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetStartAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_GetStartAddress" "', argument " "1"" of type '" "lldb::SBSymbol *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetStartAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetEndAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_GetEndAddress" "', argument " "1"" of type '" "lldb::SBSymbol *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetEndAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_GetValue" "', argument " "1"" of type '" "lldb::SBSymbol *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_GetSize" "', argument " "1"" of type '" "lldb::SBSymbol *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetPrologueByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_GetPrologueByteSize" "', argument " "1"" of type '" "lldb::SBSymbol *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetPrologueByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SymbolType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_GetType" "', argument " "1"" of type '" "lldb::SBSymbol *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SymbolType)(arg1)->GetType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_GetID" "', argument " "1"" of type '" "lldb::SBSymbol const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBSymbol const *)arg1)->GetID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  lldb::SBSymbol *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSymbol___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol___eq__" "', argument " "1"" of type '" "lldb::SBSymbol const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBSymbol,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSymbol___eq__" "', argument " "2"" of type '" "lldb::SBSymbol const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbol___eq__" "', argument " "2"" of type '" "lldb::SBSymbol const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBSymbol * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBSymbol const *)arg1)->operator ==((lldb::SBSymbol const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBSymbol___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  lldb::SBSymbol *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSymbol___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol___ne__" "', argument " "1"" of type '" "lldb::SBSymbol const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBSymbol,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSymbol___ne__" "', argument " "2"" of type '" "lldb::SBSymbol const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbol___ne__" "', argument " "2"" of type '" "lldb::SBSymbol const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBSymbol * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBSymbol const *)arg1)->operator !=((lldb::SBSymbol const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSymbol_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_GetDescription" "', argument " "1"" of type '" "lldb::SBSymbol *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSymbol_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbol_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_IsExternal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_IsExternal" "', argument " "1"" of type '" "lldb::SBSymbol *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsExternal();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_IsSynthetic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_IsSynthetic" "', argument " "1"" of type '" "lldb::SBSymbol *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsSynthetic();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_IsDebug(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_IsDebug" "', argument " "1"" of type '" "lldb::SBSymbol const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBSymbol const *)arg1)->IsDebug();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetTypeAsString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SymbolType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBSymbol_GetTypeAsString" "', argument " "1"" of type '" "lldb::SymbolType""'");
  } 
  arg1 = static_cast< lldb::SymbolType >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBSymbol::GetTypeAsString(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol_GetTypeFromString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SymbolType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol_GetTypeFromString" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SymbolType)lldb::SBSymbol::GetTypeFromString((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbol___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbol *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbol, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbol___repr__" "', argument " "1"" of type '" "lldb::SBSymbol *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBSymbol___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBSymbol_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBSymbol, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBSymbol_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBSymbolContext__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBSymbolContext *)new lldb::SBSymbolContext();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBSymbolContext__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBSymbolContext *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBSymbolContext,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBSymbolContext" "', argument " "1"" of type '" "lldb::SBSymbolContext const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBSymbolContext" "', argument " "1"" of type '" "lldb::SBSymbolContext const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBSymbolContext *)new lldb::SBSymbolContext((lldb::SBSymbolContext const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBSymbolContext(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBSymbolContext", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBSymbolContext__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBSymbolContext__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBSymbolContext'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBSymbolContext::SBSymbolContext()\n"
    "    lldb::SBSymbolContext::SBSymbolContext(lldb::SBSymbolContext const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBSymbolContext(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBSymbolContext" "', argument " "1"" of type '" "lldb::SBSymbolContext *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext___nonzero__" "', argument " "1"" of type '" "lldb::SBSymbolContext const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBSymbolContext const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext_IsValid" "', argument " "1"" of type '" "lldb::SBSymbolContext const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBSymbolContext const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext_GetModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBModule result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext_GetModule" "', argument " "1"" of type '" "lldb::SBSymbolContext *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetModule();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBModule(result)), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext_GetCompileUnit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBCompileUnit result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext_GetCompileUnit" "', argument " "1"" of type '" "lldb::SBSymbolContext *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetCompileUnit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBCompileUnit(result)), SWIGTYPE_p_lldb__SBCompileUnit, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext_GetFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFunction result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext_GetFunction" "', argument " "1"" of type '" "lldb::SBSymbolContext *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetFunction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFunction(result)), SWIGTYPE_p_lldb__SBFunction, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext_GetBlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBlock result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext_GetBlock" "', argument " "1"" of type '" "lldb::SBSymbolContext *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetBlock();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBlock(result)), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext_GetLineEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBLineEntry result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext_GetLineEntry" "', argument " "1"" of type '" "lldb::SBSymbolContext *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetLineEntry();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBLineEntry(result)), SWIGTYPE_p_lldb__SBLineEntry, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext_GetSymbol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBSymbol result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext_GetSymbol" "', argument " "1"" of type '" "lldb::SBSymbolContext *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSymbol();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbol(result)), SWIGTYPE_p_lldb__SBSymbol, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext_SetModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  lldb::SBModule arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSymbolContext_SetModule", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext_SetModule" "', argument " "1"" of type '" "lldb::SBSymbolContext *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBModule,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSymbolContext_SetModule" "', argument " "2"" of type '" "lldb::SBModule""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbolContext_SetModule" "', argument " "2"" of type '" "lldb::SBModule""'");
    } else {
      lldb::SBModule * temp = reinterpret_cast< lldb::SBModule * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetModule(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext_SetCompileUnit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  lldb::SBCompileUnit arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSymbolContext_SetCompileUnit", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext_SetCompileUnit" "', argument " "1"" of type '" "lldb::SBSymbolContext *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBCompileUnit,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSymbolContext_SetCompileUnit" "', argument " "2"" of type '" "lldb::SBCompileUnit""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbolContext_SetCompileUnit" "', argument " "2"" of type '" "lldb::SBCompileUnit""'");
    } else {
      lldb::SBCompileUnit * temp = reinterpret_cast< lldb::SBCompileUnit * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetCompileUnit(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext_SetFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  lldb::SBFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSymbolContext_SetFunction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext_SetFunction" "', argument " "1"" of type '" "lldb::SBSymbolContext *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFunction,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSymbolContext_SetFunction" "', argument " "2"" of type '" "lldb::SBFunction""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbolContext_SetFunction" "', argument " "2"" of type '" "lldb::SBFunction""'");
    } else {
      lldb::SBFunction * temp = reinterpret_cast< lldb::SBFunction * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetFunction(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext_SetBlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  lldb::SBBlock arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSymbolContext_SetBlock", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext_SetBlock" "', argument " "1"" of type '" "lldb::SBSymbolContext *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBBlock,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSymbolContext_SetBlock" "', argument " "2"" of type '" "lldb::SBBlock""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbolContext_SetBlock" "', argument " "2"" of type '" "lldb::SBBlock""'");
    } else {
      lldb::SBBlock * temp = reinterpret_cast< lldb::SBBlock * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetBlock(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext_SetLineEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  lldb::SBLineEntry arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSymbolContext_SetLineEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext_SetLineEntry" "', argument " "1"" of type '" "lldb::SBSymbolContext *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBLineEntry,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSymbolContext_SetLineEntry" "', argument " "2"" of type '" "lldb::SBLineEntry""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbolContext_SetLineEntry" "', argument " "2"" of type '" "lldb::SBLineEntry""'");
    } else {
      lldb::SBLineEntry * temp = reinterpret_cast< lldb::SBLineEntry * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetLineEntry(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext_SetSymbol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  lldb::SBSymbol arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSymbolContext_SetSymbol", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext_SetSymbol" "', argument " "1"" of type '" "lldb::SBSymbolContext *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBSymbol,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSymbolContext_SetSymbol" "', argument " "2"" of type '" "lldb::SBSymbol""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbolContext_SetSymbol" "', argument " "2"" of type '" "lldb::SBSymbol""'");
    } else {
      lldb::SBSymbol * temp = reinterpret_cast< lldb::SBSymbol * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetSymbol(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext_GetParentOfInlinedScope(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  lldb::SBAddress *arg2 = 0 ;
  lldb::SBAddress *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBSymbolContext result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSymbolContext_GetParentOfInlinedScope", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext_GetParentOfInlinedScope" "', argument " "1"" of type '" "lldb::SBSymbolContext const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSymbolContext_GetParentOfInlinedScope" "', argument " "2"" of type '" "lldb::SBAddress const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbolContext_GetParentOfInlinedScope" "', argument " "2"" of type '" "lldb::SBAddress const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAddress * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBAddress,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBSymbolContext_GetParentOfInlinedScope" "', argument " "3"" of type '" "lldb::SBAddress &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbolContext_GetParentOfInlinedScope" "', argument " "3"" of type '" "lldb::SBAddress &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBAddress * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBSymbolContext const *)arg1)->GetParentOfInlinedScope((lldb::SBAddress const &)*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContext(result)), SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSymbolContext_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext_GetDescription" "', argument " "1"" of type '" "lldb::SBSymbolContext *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSymbolContext_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbolContext_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContext___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContext *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContext___repr__" "', argument " "1"" of type '" "lldb::SBSymbolContext *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContext * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBSymbolContext___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBSymbolContext_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBSymbolContext, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBSymbolContext_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBSymbolContextList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContextList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBSymbolContextList *)new lldb::SBSymbolContextList();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBSymbolContextList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContextList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBSymbolContextList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBSymbolContextList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBSymbolContextList" "', argument " "1"" of type '" "lldb::SBSymbolContextList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBSymbolContextList" "', argument " "1"" of type '" "lldb::SBSymbolContextList const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContextList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBSymbolContextList *)new lldb::SBSymbolContextList((lldb::SBSymbolContextList const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBSymbolContextList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBSymbolContextList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBSymbolContextList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBSymbolContextList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBSymbolContextList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBSymbolContextList::SBSymbolContextList()\n"
    "    lldb::SBSymbolContextList::SBSymbolContextList(lldb::SBSymbolContextList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBSymbolContextList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContextList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBSymbolContextList" "', argument " "1"" of type '" "lldb::SBSymbolContextList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContextList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContextList___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContextList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContextList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContextList___nonzero__" "', argument " "1"" of type '" "lldb::SBSymbolContextList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContextList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBSymbolContextList const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContextList_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContextList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContextList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContextList_IsValid" "', argument " "1"" of type '" "lldb::SBSymbolContextList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContextList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBSymbolContextList const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContextList_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContextList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContextList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContextList_GetSize" "', argument " "1"" of type '" "lldb::SBSymbolContextList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContextList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBSymbolContextList const *)arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContextList_GetContextAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContextList *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBSymbolContext result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSymbolContextList_GetContextAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContextList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContextList_GetContextAtIndex" "', argument " "1"" of type '" "lldb::SBSymbolContextList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContextList * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBSymbolContextList_GetContextAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetContextAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContext(result)), SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContextList_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContextList *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBSymbolContextList_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContextList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContextList_GetDescription" "', argument " "1"" of type '" "lldb::SBSymbolContextList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContextList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSymbolContextList_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbolContextList_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContextList_Append__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContextList *arg1 = 0 ;
  lldb::SBSymbolContext *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContextList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContextList_Append" "', argument " "1"" of type '" "lldb::SBSymbolContextList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContextList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBSymbolContext,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSymbolContextList_Append" "', argument " "2"" of type '" "lldb::SBSymbolContext &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbolContextList_Append" "', argument " "2"" of type '" "lldb::SBSymbolContext &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBSymbolContext * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Append(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContextList_Append__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContextList *arg1 = 0 ;
  lldb::SBSymbolContextList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContextList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContextList_Append" "', argument " "1"" of type '" "lldb::SBSymbolContextList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContextList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBSymbolContextList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBSymbolContextList_Append" "', argument " "2"" of type '" "lldb::SBSymbolContextList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBSymbolContextList_Append" "', argument " "2"" of type '" "lldb::SBSymbolContextList &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBSymbolContextList * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Append(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContextList_Append(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBSymbolContextList_Append", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBSymbolContextList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBSymbolContextList_Append__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBSymbolContextList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBSymbolContextList_Append__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBSymbolContextList_Append'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBSymbolContextList::Append(lldb::SBSymbolContext &)\n"
    "    lldb::SBSymbolContextList::Append(lldb::SBSymbolContextList &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBSymbolContextList_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContextList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContextList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContextList_Clear" "', argument " "1"" of type '" "lldb::SBSymbolContextList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContextList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBSymbolContextList___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBSymbolContextList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBSymbolContextList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBSymbolContextList___repr__" "', argument " "1"" of type '" "lldb::SBSymbolContextList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBSymbolContextList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBSymbolContextList___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBSymbolContextList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBSymbolContextList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBTarget__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBTarget *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTarget *)new lldb::SBTarget();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTarget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBTarget *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTarget" "', argument " "1"" of type '" "lldb::SBTarget const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBTarget" "', argument " "1"" of type '" "lldb::SBTarget const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTarget *)new lldb::SBTarget((lldb::SBTarget const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTarget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBTarget", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBTarget__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTarget__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::SBTarget()\n"
    "    lldb::SBTarget::SBTarget(lldb::SBTarget const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBTarget" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget___nonzero__" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTarget const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_IsValid" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTarget const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_EventIsTargetEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_EventIsTargetEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_EventIsTargetEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBTarget::EventIsTargetEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetTargetFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTarget result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetTargetFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_GetTargetFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBTarget::GetTargetFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetCreatedTargetFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTarget result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetCreatedTargetFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_GetCreatedTargetFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBTarget::GetCreatedTargetFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetNumModulesFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetNumModulesFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_GetNumModulesFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)lldb::SBTarget::GetNumModulesFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetModuleAtIndexFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  lldb::SBEvent *arg2 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBModule result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_GetModuleAtIndexFromEvent", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBTarget_GetModuleAtIndexFromEvent" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_GetModuleAtIndexFromEvent" "', argument " "2"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_GetModuleAtIndexFromEvent" "', argument " "2"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBEvent * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBTarget::GetModuleAtIndexFromEvent(arg1,(lldb::SBEvent const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBModule(result)), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetBroadcasterClassName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_GetBroadcasterClassName", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBTarget::GetBroadcasterClassName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBProcess result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetProcess" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetProcess();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_SetCollectingStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_SetCollectingStats", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_SetCollectingStats" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_SetCollectingStats" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetCollectingStats(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetCollectingStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetCollectingStats" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetCollectingStats();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetStatistics__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBStructuredData result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetStatistics" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetStatistics();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetStatistics__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBStatisticsOptions arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  lldb::SBStructuredData result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetStatistics" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStatisticsOptions,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_GetStatistics" "', argument " "2"" of type '" "lldb::SBStatisticsOptions""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_GetStatistics" "', argument " "2"" of type '" "lldb::SBStatisticsOptions""'");
    } else {
      lldb::SBStatisticsOptions * temp = reinterpret_cast< lldb::SBStatisticsOptions * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetStatistics(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBStructuredData(result)), SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetStatistics(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_GetStatistics", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBTarget_GetStatistics__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBStatisticsOptions, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBTarget_GetStatistics__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_GetStatistics'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::GetStatistics()\n"
    "    lldb::SBTarget::GetStatistics(lldb::SBStatisticsOptions)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_ResetStatistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_ResetStatistics" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->ResetStatistics();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetPlatform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBPlatform result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetPlatform" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetPlatform();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBPlatform(result)), SWIGTYPE_p_lldb__SBPlatform, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetEnvironment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBEnvironment result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetEnvironment" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetEnvironment();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBEnvironment(result)), SWIGTYPE_p_lldb__SBEnvironment, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_Install(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBError result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_Install" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Install();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_Launch__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBListener *arg2 = 0 ;
  char **arg3 = 0 ;
  char **arg4 = 0 ;
  char *arg5 = 0 ;
  char *arg6 = 0 ;
  char *arg7 = 0 ;
  char *arg8 = 0 ;
  uint32_t arg9 ;
  bool arg10 ;
  lldb::SBError *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  int res7 ;
  char *buf7 = 0 ;
  int alloc7 = 0 ;
  int res8 ;
  char *buf8 = 0 ;
  int alloc8 = 0 ;
  unsigned int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  lldb::SBProcess result;
  
  (void)self;
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_Launch" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBListener,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_Launch" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_Launch" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBListener * >(argp2);
  {
    /* Check if is a list  */
    if (PythonList::Check(swig_obj[2])) {
      PythonList list(PyRefType::Borrowed, swig_obj[2]);
      int size = list.GetSize();
      int i = 0;
      arg3 = (char **)malloc((size + 1) * sizeof(char *));
      for (i = 0; i < size; i++) {
        PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
        if (!py_str.IsAllocated()) {
          PyErr_SetString(PyExc_TypeError, "list must contain strings");
          SWIG_fail;
        }
        
        arg3[i] = const_cast<char *>(py_str.GetString().data());
      }
      arg3[i] = 0;
    } else if (swig_obj[2] == Py_None) {
      arg3 = NULL;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  {
    /* Check if is a list  */
    if (PythonList::Check(swig_obj[3])) {
      PythonList list(PyRefType::Borrowed, swig_obj[3]);
      int size = list.GetSize();
      int i = 0;
      arg4 = (char **)malloc((size + 1) * sizeof(char *));
      for (i = 0; i < size; i++) {
        PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
        if (!py_str.IsAllocated()) {
          PyErr_SetString(PyExc_TypeError, "list must contain strings");
          SWIG_fail;
        }
        
        arg4[i] = const_cast<char *>(py_str.GetString().data());
      }
      arg4[i] = 0;
    } else if (swig_obj[3] == Py_None) {
      arg4 = NULL;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBTarget_Launch" "', argument " "5"" of type '" "char const *""'");
  }
  arg5 = reinterpret_cast< char * >(buf5);
  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SBTarget_Launch" "', argument " "6"" of type '" "char const *""'");
  }
  arg6 = reinterpret_cast< char * >(buf6);
  res7 = SWIG_AsCharPtrAndSize(swig_obj[6], &buf7, NULL, &alloc7);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SBTarget_Launch" "', argument " "7"" of type '" "char const *""'");
  }
  arg7 = reinterpret_cast< char * >(buf7);
  res8 = SWIG_AsCharPtrAndSize(swig_obj[7], &buf8, NULL, &alloc8);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SBTarget_Launch" "', argument " "8"" of type '" "char const *""'");
  }
  arg8 = reinterpret_cast< char * >(buf8);
  ecode9 = SWIG_AsVal_unsigned_SS_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SBTarget_Launch" "', argument " "9"" of type '" "uint32_t""'");
  } 
  arg9 = static_cast< uint32_t >(val9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SBTarget_Launch" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "SBTarget_Launch" "', argument " "11"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_Launch" "', argument " "11"" of type '" "lldb::SBError &""'"); 
  }
  arg11 = reinterpret_cast< lldb::SBError * >(argp11);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Launch(*arg2,(char const **)arg3,(char const **)arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,(char const *)arg8,arg9,arg10,*arg11);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  {
    free((char *) arg3);
  }
  {
    free((char *) arg4);
  }
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return resultobj;
fail:
  {
    free((char *) arg3);
  }
  {
    free((char *) arg4);
  }
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_LoadCore__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBProcess result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_LoadCore" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_LoadCore" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->LoadCore((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_LoadCore__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBError *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBProcess result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_LoadCore" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_LoadCore" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_LoadCore" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_LoadCore" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBError * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->LoadCore((char const *)arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_LoadCore(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_LoadCore", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBTarget_LoadCore__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBTarget_LoadCore__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_LoadCore'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::LoadCore(char const *)\n"
    "    lldb::SBTarget::LoadCore(char const *,lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_LaunchSimple(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char **arg2 = 0 ;
  char **arg3 = 0 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  PyObject *swig_obj[4] ;
  lldb::SBProcess result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_LaunchSimple", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_LaunchSimple" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    /* Check if is a list  */
    if (PythonList::Check(swig_obj[1])) {
      PythonList list(PyRefType::Borrowed, swig_obj[1]);
      int size = list.GetSize();
      int i = 0;
      arg2 = (char **)malloc((size + 1) * sizeof(char *));
      for (i = 0; i < size; i++) {
        PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
        if (!py_str.IsAllocated()) {
          PyErr_SetString(PyExc_TypeError, "list must contain strings");
          SWIG_fail;
        }
        
        arg2[i] = const_cast<char *>(py_str.GetString().data());
      }
      arg2[i] = 0;
    } else if (swig_obj[1] == Py_None) {
      arg2 = NULL;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  {
    /* Check if is a list  */
    if (PythonList::Check(swig_obj[2])) {
      PythonList list(PyRefType::Borrowed, swig_obj[2]);
      int size = list.GetSize();
      int i = 0;
      arg3 = (char **)malloc((size + 1) * sizeof(char *));
      for (i = 0; i < size; i++) {
        PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
        if (!py_str.IsAllocated()) {
          PyErr_SetString(PyExc_TypeError, "list must contain strings");
          SWIG_fail;
        }
        
        arg3[i] = const_cast<char *>(py_str.GetString().data());
      }
      arg3[i] = 0;
    } else if (swig_obj[2] == Py_None) {
      arg3 = NULL;
    } else {
      PyErr_SetString(PyExc_TypeError, "not a list");
      SWIG_fail;
    }
  }
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_LaunchSimple" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->LaunchSimple((char const **)arg2,(char const **)arg3,(char const *)arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  {
    free((char *) arg2);
  }
  {
    free((char *) arg3);
  }
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  {
    free((char *) arg2);
  }
  {
    free((char *) arg3);
  }
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_Launch__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBLaunchInfo *arg2 = 0 ;
  lldb::SBError *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBProcess result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_Launch" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBLaunchInfo,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_Launch" "', argument " "2"" of type '" "lldb::SBLaunchInfo &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_Launch" "', argument " "2"" of type '" "lldb::SBLaunchInfo &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBLaunchInfo * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_Launch" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_Launch" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBError * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Launch(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_Launch(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_Launch", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBLaunchInfo, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBTarget_Launch__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          /* Check if is a list  */
          _v = 1;
          if (PythonList::Check(argv[2])) {
            PythonList list(PyRefType::Borrowed, argv[2]);
            int size = list.GetSize();
            int i = 0;
            for (i = 0; i < size; i++) {
              PythonString s = list.GetItemAtIndex(i).AsType<PythonString>();
              if (!s.IsAllocated()) {
                _v = 0;
              }
            }
          } else {
            _v = ((argv[2] == Py_None) ? 1 : 0);
          }
        }
        if (_v) {
          {
            /* Check if is a list  */
            _v = 1;
            if (PythonList::Check(argv[3])) {
              PythonList list(PyRefType::Borrowed, argv[3]);
              int size = list.GetSize();
              int i = 0;
              for (i = 0; i < size; i++) {
                PythonString s = list.GetItemAtIndex(i).AsType<PythonString>();
                if (!s.IsAllocated()) {
                  _v = 0;
                }
              }
            } else {
              _v = ((argv[3] == Py_None) ? 1 : 0);
            }
          }
          if (_v) {
            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsCharPtrAndSize(argv[5], 0, NULL, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsCharPtrAndSize(argv[6], 0, NULL, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsCharPtrAndSize(argv[7], 0, NULL, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_unsigned_SS_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_SBTarget_Launch__SWIG_0(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_Launch'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::Launch(lldb::SBListener &,char const **,char const **,char const *,char const *,char const *,char const *,uint32_t,bool,lldb::SBError &)\n"
    "    lldb::SBTarget::Launch(lldb::SBLaunchInfo &,lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_Attach(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBAttachInfo *arg2 = 0 ;
  lldb::SBError *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBProcess result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_Attach", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_Attach" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAttachInfo,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_Attach" "', argument " "2"" of type '" "lldb::SBAttachInfo &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_Attach" "', argument " "2"" of type '" "lldb::SBAttachInfo &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAttachInfo * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_Attach" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_Attach" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBError * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Attach(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_AttachToProcessWithID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBListener *arg2 = 0 ;
  lldb::pid_t arg3 ;
  lldb::SBError *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  lldb::SBProcess result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_AttachToProcessWithID", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_AttachToProcessWithID" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBListener,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_AttachToProcessWithID" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_AttachToProcessWithID" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBListener * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_AttachToProcessWithID" "', argument " "3"" of type '" "lldb::pid_t""'");
  } 
  arg3 = static_cast< lldb::pid_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_AttachToProcessWithID" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_AttachToProcessWithID" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBError * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->AttachToProcessWithID(*arg2,arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_AttachToProcessWithName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBListener *arg2 = 0 ;
  char *arg3 = 0 ;
  bool arg4 ;
  lldb::SBError *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  lldb::SBProcess result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_AttachToProcessWithName", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_AttachToProcessWithName" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBListener,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_AttachToProcessWithName" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_AttachToProcessWithName" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBListener * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_AttachToProcessWithName" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBTarget_AttachToProcessWithName" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBTarget_AttachToProcessWithName" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_AttachToProcessWithName" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBError * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->AttachToProcessWithName(*arg2,(char const *)arg3,arg4,*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_ConnectRemote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBListener *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  lldb::SBError *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  lldb::SBProcess result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_ConnectRemote", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_ConnectRemote" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBListener,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_ConnectRemote" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_ConnectRemote" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBListener * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_ConnectRemote" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_ConnectRemote" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBTarget_ConnectRemote" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_ConnectRemote" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBError * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ConnectRemote(*arg2,(char const *)arg3,(char const *)arg4,*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetExecutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFileSpec result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetExecutable" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetExecutable();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_AppendImageSearchPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  lldb::SBError *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_AppendImageSearchPath", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_AppendImageSearchPath" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_AppendImageSearchPath" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_AppendImageSearchPath" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_AppendImageSearchPath" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_AppendImageSearchPath" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBError * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->AppendImageSearchPath((char const *)arg2,(char const *)arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_AddModule__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBModule *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_AddModule" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBModule,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_AddModule" "', argument " "2"" of type '" "lldb::SBModule &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_AddModule" "', argument " "2"" of type '" "lldb::SBModule &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBModule * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->AddModule(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_AddModule__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  lldb::SBModule result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_AddModule" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_AddModule" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_AddModule" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_AddModule" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->AddModule((char const *)arg2,(char const *)arg3,(char const *)arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBModule(result)), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_AddModule__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  char *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  lldb::SBModule result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_AddModule" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_AddModule" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_AddModule" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_AddModule" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBTarget_AddModule" "', argument " "5"" of type '" "char const *""'");
  }
  arg5 = reinterpret_cast< char * >(buf5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->AddModule((char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBModule(result)), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_AddModule__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBModuleSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  lldb::SBModule result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_AddModule" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBModuleSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_AddModule" "', argument " "2"" of type '" "lldb::SBModuleSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_AddModule" "', argument " "2"" of type '" "lldb::SBModuleSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBModuleSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->AddModule((lldb::SBModuleSpec const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBModule(result)), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_AddModule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_AddModule", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBTarget_AddModule__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBTarget_AddModule__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBTarget_AddModule__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SBTarget_AddModule__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_AddModule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::AddModule(lldb::SBModule &)\n"
    "    lldb::SBTarget::AddModule(char const *,char const *,char const *)\n"
    "    lldb::SBTarget::AddModule(char const *,char const *,char const *,char const *)\n"
    "    lldb::SBTarget::AddModule(lldb::SBModuleSpec const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetNumModules(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetNumModules" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBTarget const *)arg1)->GetNumModules();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetModuleAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBModule result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_GetModuleAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetModuleAtIndex" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_GetModuleAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetModuleAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBModule(result)), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_RemoveModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBModule arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_RemoveModule", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_RemoveModule" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBModule,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_RemoveModule" "', argument " "2"" of type '" "lldb::SBModule""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_RemoveModule" "', argument " "2"" of type '" "lldb::SBModule""'");
    } else {
      lldb::SBModule * temp = reinterpret_cast< lldb::SBModule * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->RemoveModule(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetDebugger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBDebugger result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetDebugger" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBTarget const *)arg1)->GetDebugger();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBDebugger(result)), SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindModule__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  lldb::SBModule result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_FindModule" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_FindModule" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_FindModule" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindModule((lldb::SBFileSpec const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBModule(result)), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindModule__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBModuleSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  lldb::SBModule result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_FindModule" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBModuleSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_FindModule" "', argument " "2"" of type '" "lldb::SBModuleSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_FindModule" "', argument " "2"" of type '" "lldb::SBModuleSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBModuleSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBTarget const *)arg1)->FindModule((lldb::SBModuleSpec const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBModule(result)), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindModule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_FindModule", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBTarget_FindModule__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBTarget_FindModule__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_FindModule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::FindModule(lldb::SBFileSpec const &)\n"
    "    lldb::SBTarget::FindModule(lldb::SBModuleSpec const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindCompileUnits(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBSymbolContextList result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_FindCompileUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_FindCompileUnits" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_FindCompileUnits" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_FindCompileUnits" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindCompileUnits((lldb::SBFileSpec const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContextList(result)), SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetByteOrder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::ByteOrder result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetByteOrder" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ByteOrder)(arg1)->GetByteOrder();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetAddressByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetAddressByteSize" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetAddressByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetTriple(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetTriple" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetTriple();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetArchName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetArchName" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBTarget const *)arg1)->GetArchName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetABIName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetABIName" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetABIName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetLabel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetLabel" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBTarget const *)arg1)->GetLabel();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetGloballyUniqueID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::user_id_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetGloballyUniqueID" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::user_id_t)((lldb::SBTarget const *)arg1)->GetGloballyUniqueID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetTargetSessionName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetTargetSessionName" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBTarget const *)arg1)->GetTargetSessionName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_SetLabel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_SetLabel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_SetLabel" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_SetLabel" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetLabel((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetMinimumOpcodeByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetMinimumOpcodeByteSize" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBTarget const *)arg1)->GetMinimumOpcodeByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetMaximumOpcodeByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetMaximumOpcodeByteSize" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBTarget const *)arg1)->GetMaximumOpcodeByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetDataByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetDataByteSize" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetDataByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetCodeByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetCodeByteSize" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetCodeByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetMaximumNumberOfChildrenToDisplay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetMaximumNumberOfChildrenToDisplay" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBTarget const *)arg1)->GetMaximumNumberOfChildrenToDisplay();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_SetSectionLoadAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBSection arg2 ;
  lldb::addr_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_SetSectionLoadAddress", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_SetSectionLoadAddress" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBSection,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_SetSectionLoadAddress" "', argument " "2"" of type '" "lldb::SBSection""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_SetSectionLoadAddress" "', argument " "2"" of type '" "lldb::SBSection""'");
    } else {
      lldb::SBSection * temp = reinterpret_cast< lldb::SBSection * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_SetSectionLoadAddress" "', argument " "3"" of type '" "lldb::addr_t""'");
  } 
  arg3 = static_cast< lldb::addr_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetSectionLoadAddress(SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_ClearSectionLoadAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBSection arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_ClearSectionLoadAddress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_ClearSectionLoadAddress" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBSection,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_ClearSectionLoadAddress" "', argument " "2"" of type '" "lldb::SBSection""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_ClearSectionLoadAddress" "', argument " "2"" of type '" "lldb::SBSection""'");
    } else {
      lldb::SBSection * temp = reinterpret_cast< lldb::SBSection * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ClearSectionLoadAddress(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_SetModuleLoadAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBModule arg2 ;
  uint64_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_SetModuleLoadAddress", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_SetModuleLoadAddress" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBModule,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_SetModuleLoadAddress" "', argument " "2"" of type '" "lldb::SBModule""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_SetModuleLoadAddress" "', argument " "2"" of type '" "lldb::SBModule""'");
    } else {
      lldb::SBModule * temp = reinterpret_cast< lldb::SBModule * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_SetModuleLoadAddress" "', argument " "3"" of type '" "uint64_t""'");
  } 
  arg3 = static_cast< uint64_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetModuleLoadAddress(SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_ClearModuleLoadAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBModule arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_ClearModuleLoadAddress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_ClearModuleLoadAddress" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBModule,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_ClearModuleLoadAddress" "', argument " "2"" of type '" "lldb::SBModule""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_ClearModuleLoadAddress" "', argument " "2"" of type '" "lldb::SBModule""'");
    } else {
      lldb::SBModule * temp = reinterpret_cast< lldb::SBModule * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ClearModuleLoadAddress(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindFunctions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  lldb::SBSymbolContextList result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_FindFunctions" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_FindFunctions" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_FindFunctions" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindFunctions((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContextList(result)), SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindFunctions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBSymbolContextList result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_FindFunctions" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_FindFunctions" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindFunctions((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContextList(result)), SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindFunctions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_FindFunctions", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBTarget_FindFunctions__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBTarget_FindFunctions__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_FindFunctions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::FindFunctions(char const *,uint32_t)\n"
    "    lldb::SBTarget::FindFunctions(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindGlobalVariables__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  lldb::SBValueList result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_FindGlobalVariables" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_FindGlobalVariables" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_FindGlobalVariables" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindGlobalVariables((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValueList(result)), SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindFirstGlobalVariable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_FindFirstGlobalVariable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_FindFirstGlobalVariable" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_FindFirstGlobalVariable" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindFirstGlobalVariable((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindGlobalVariables__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  lldb::MatchType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  lldb::SBValueList result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_FindGlobalVariables" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_FindGlobalVariables" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_FindGlobalVariables" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBTarget_FindGlobalVariables" "', argument " "4"" of type '" "lldb::MatchType""'");
  } 
  arg4 = static_cast< lldb::MatchType >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindGlobalVariables((char const *)arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValueList(result)), SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindGlobalVariables(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_FindGlobalVariables", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBTarget_FindGlobalVariables__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBTarget_FindGlobalVariables__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_FindGlobalVariables'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::FindGlobalVariables(char const *,uint32_t)\n"
    "    lldb::SBTarget::FindGlobalVariables(char const *,uint32_t,lldb::MatchType)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindGlobalFunctions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  lldb::MatchType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  lldb::SBSymbolContextList result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_FindGlobalFunctions", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_FindGlobalFunctions" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_FindGlobalFunctions" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_FindGlobalFunctions" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBTarget_FindGlobalFunctions" "', argument " "4"" of type '" "lldb::MatchType""'");
  } 
  arg4 = static_cast< lldb::MatchType >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindGlobalFunctions((char const *)arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContextList(result)), SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_Clear" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_ResolveFileAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::addr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_ResolveFileAddress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_ResolveFileAddress" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_ResolveFileAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ResolveFileAddress(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_ResolveLoadAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::addr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_ResolveLoadAddress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_ResolveLoadAddress" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_ResolveLoadAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ResolveLoadAddress(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_ResolvePastLoadAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  uint32_t arg2 ;
  lldb::addr_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_ResolvePastLoadAddress", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_ResolvePastLoadAddress" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_ResolvePastLoadAddress" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_ResolvePastLoadAddress" "', argument " "3"" of type '" "lldb::addr_t""'");
  } 
  arg3 = static_cast< lldb::addr_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ResolvePastLoadAddress(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_ResolveSymbolContextForAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBAddress *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBSymbolContext result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_ResolveSymbolContextForAddress", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_ResolveSymbolContextForAddress" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_ResolveSymbolContextForAddress" "', argument " "2"" of type '" "lldb::SBAddress const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_ResolveSymbolContextForAddress" "', argument " "2"" of type '" "lldb::SBAddress const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAddress * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_ResolveSymbolContextForAddress" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ResolveSymbolContextForAddress((lldb::SBAddress const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContext(result)), SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_ReadMemory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBAddress arg2 ;
  void *arg3 = 0 ;
  size_t arg4 ;
  lldb::SBError *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[4] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_ReadMemory", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_ReadMemory" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_ReadMemory" "', argument " "2"" of type '" "lldb::SBAddress const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_ReadMemory" "', argument " "2"" of type '" "lldb::SBAddress const""'");
    } else {
      lldb::SBAddress * temp = reinterpret_cast< lldb::SBAddress * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    if (PyLong_Check(swig_obj[2])) {
      arg4 = PyLong_AsLong(swig_obj[2]);
    } else {
      PyErr_SetString(PyExc_ValueError, "Expecting an integer or long object");
      SWIG_fail;
    }
    if (arg4 <= 0) {
      PyErr_SetString(PyExc_ValueError, "Positive integer expected");
      SWIG_fail;
    }
    arg3 = (void *)malloc(arg4);
  }
  res5 = SWIG_ConvertPtr(swig_obj[3], &argp5, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBTarget_ReadMemory" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_ReadMemory" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBError * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ReadMemory(SWIG_STD_MOVE(arg2),arg3,SWIG_STD_MOVE(arg4),*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  {
    Py_XDECREF(resultobj); /* Blow away any previous result */
    if (result == 0) {
      resultobj = Py_None;
      Py_INCREF(resultobj);
    } else {
      PythonBytes bytes(static_cast<const uint8_t *>(arg3), result);
      resultobj = bytes.release();
    }
    free(arg3);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByLocation((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByLocation((lldb::SBFileSpec const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  uint32_t arg3 ;
  lldb::addr_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned long long val4 ;
  int ecode4 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "4"" of type '" "lldb::addr_t""'");
  } 
  arg4 = static_cast< lldb::addr_t >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByLocation((lldb::SBFileSpec const &)*arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  uint32_t arg3 ;
  lldb::addr_t arg4 ;
  lldb::SBFileSpecList *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned long long val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "4"" of type '" "lldb::addr_t""'");
  } 
  arg4 = static_cast< lldb::addr_t >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBFileSpecList,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "5"" of type '" "lldb::SBFileSpecList &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "5"" of type '" "lldb::SBFileSpecList &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBFileSpecList * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByLocation((lldb::SBFileSpec const &)*arg2,arg3,arg4,*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  lldb::addr_t arg5 ;
  lldb::SBFileSpecList *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned long long val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "5"" of type '" "lldb::addr_t""'");
  } 
  arg5 = static_cast< lldb::addr_t >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_lldb__SBFileSpecList,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "6"" of type '" "lldb::SBFileSpecList &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "6"" of type '" "lldb::SBFileSpecList &""'"); 
  }
  arg6 = reinterpret_cast< lldb::SBFileSpecList * >(argp6);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByLocation((lldb::SBFileSpec const &)*arg2,arg3,arg4,arg5,*arg6);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  lldb::addr_t arg5 ;
  lldb::SBFileSpecList *arg6 = 0 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned long long val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "2"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "5"" of type '" "lldb::addr_t""'");
  } 
  arg5 = static_cast< lldb::addr_t >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_lldb__SBFileSpecList,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "6"" of type '" "lldb::SBFileSpecList &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "6"" of type '" "lldb::SBFileSpecList &""'"); 
  }
  arg6 = reinterpret_cast< lldb::SBFileSpecList * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SBTarget_BreakpointCreateByLocation" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByLocation((lldb::SBFileSpec const &)*arg2,arg3,arg4,arg5,*arg6,arg7);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByLocation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_BreakpointCreateByLocation", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_5(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_BreakpointCreateByLocation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::BreakpointCreateByLocation(char const *,uint32_t)\n"
    "    lldb::SBTarget::BreakpointCreateByLocation(lldb::SBFileSpec const &,uint32_t)\n"
    "    lldb::SBTarget::BreakpointCreateByLocation(lldb::SBFileSpec const &,uint32_t,lldb::addr_t)\n"
    "    lldb::SBTarget::BreakpointCreateByLocation(lldb::SBFileSpec const &,uint32_t,lldb::addr_t,lldb::SBFileSpecList &)\n"
    "    lldb::SBTarget::BreakpointCreateByLocation(lldb::SBFileSpec const &,uint32_t,uint32_t,lldb::addr_t,lldb::SBFileSpecList &)\n"
    "    lldb::SBTarget::BreakpointCreateByLocation(lldb::SBFileSpec const &,uint32_t,uint32_t,lldb::addr_t,lldb::SBFileSpecList &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByName((char const *)arg2,(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBFileSpecList *arg3 = 0 ;
  lldb::SBFileSpecList *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "3"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByName" "', argument " "3"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpecList * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "4"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByName" "', argument " "4"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBFileSpecList * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByName((char const *)arg2,(lldb::SBFileSpecList const &)*arg3,(lldb::SBFileSpecList const &)*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  lldb::SBFileSpecList *arg4 = 0 ;
  lldb::SBFileSpecList *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "4"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByName" "', argument " "4"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBFileSpecList * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "5"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByName" "', argument " "5"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBFileSpecList * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByName((char const *)arg2,arg3,(lldb::SBFileSpecList const &)*arg4,(lldb::SBFileSpecList const &)*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  lldb::LanguageType arg4 ;
  lldb::SBFileSpecList *arg5 = 0 ;
  lldb::SBFileSpecList *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "4"" of type '" "lldb::LanguageType""'");
  } 
  arg4 = static_cast< lldb::LanguageType >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "5"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByName" "', argument " "5"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBFileSpecList * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "6"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByName" "', argument " "6"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg6 = reinterpret_cast< lldb::SBFileSpecList * >(argp6);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByName((char const *)arg2,arg3,arg4,(lldb::SBFileSpecList const &)*arg5,(lldb::SBFileSpecList const &)*arg6);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  lldb::LanguageType arg4 ;
  lldb::addr_t arg5 ;
  bool arg6 ;
  lldb::SBFileSpecList *arg7 = 0 ;
  lldb::SBFileSpecList *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned long long val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "4"" of type '" "lldb::LanguageType""'");
  } 
  arg4 = static_cast< lldb::LanguageType >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "5"" of type '" "lldb::addr_t""'");
  } 
  arg5 = static_cast< lldb::addr_t >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "7"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByName" "', argument " "7"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg7 = reinterpret_cast< lldb::SBFileSpecList * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SBTarget_BreakpointCreateByName" "', argument " "8"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByName" "', argument " "8"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg8 = reinterpret_cast< lldb::SBFileSpecList * >(argp8);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByName((char const *)arg2,arg3,arg4,arg5,arg6,(lldb::SBFileSpecList const &)*arg7,(lldb::SBFileSpecList const &)*arg8);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_BreakpointCreateByName", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBTarget_BreakpointCreateByName__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBTarget_BreakpointCreateByName__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBTarget_BreakpointCreateByName__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SBTarget_BreakpointCreateByName__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_SBTarget_BreakpointCreateByName__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_SBTarget_BreakpointCreateByName__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_BreakpointCreateByName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::BreakpointCreateByName(char const *,char const *)\n"
    "    lldb::SBTarget::BreakpointCreateByName(char const *)\n"
    "    lldb::SBTarget::BreakpointCreateByName(char const *,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n"
    "    lldb::SBTarget::BreakpointCreateByName(char const *,uint32_t,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n"
    "    lldb::SBTarget::BreakpointCreateByName(char const *,uint32_t,lldb::LanguageType,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n"
    "    lldb::SBTarget::BreakpointCreateByName(char const *,uint32_t,lldb::LanguageType,lldb::addr_t,bool,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByNames__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char **arg2 = 0 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  lldb::SBFileSpecList *arg5 = 0 ;
  lldb::SBFileSpecList *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    using namespace lldb_private;
    /* Check if is a list  */
    if (PythonList::Check(swig_obj[1])) {
      PythonList list(PyRefType::Borrowed, swig_obj[1]);
      arg3 = list.GetSize();
      int i = 0;
      arg2 = (char**)malloc((arg3+1)*sizeof(char*));
      for (i = 0; i < arg3; i++) {
        PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
        if (!py_str.IsAllocated()) {
          PyErr_SetString(PyExc_TypeError,"list must contain strings and blubby");
          free(arg2);
          return nullptr;
        }
        
        arg2[i] = const_cast<char*>(py_str.GetString().data());
      }
      arg2[i] = 0;
    } else if (swig_obj[1] == Py_None) {
      arg2 =  NULL;
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[3], &argp5, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "5"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "5"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBFileSpecList * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[4], &argp6, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "6"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "6"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg6 = reinterpret_cast< lldb::SBFileSpecList * >(argp6);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByNames((char const **)arg2,arg3,arg4,(lldb::SBFileSpecList const &)*arg5,(lldb::SBFileSpecList const &)*arg6);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByNames__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char **arg2 = 0 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  lldb::LanguageType arg5 ;
  lldb::SBFileSpecList *arg6 = 0 ;
  lldb::SBFileSpecList *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    using namespace lldb_private;
    /* Check if is a list  */
    if (PythonList::Check(swig_obj[1])) {
      PythonList list(PyRefType::Borrowed, swig_obj[1]);
      arg3 = list.GetSize();
      int i = 0;
      arg2 = (char**)malloc((arg3+1)*sizeof(char*));
      for (i = 0; i < arg3; i++) {
        PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
        if (!py_str.IsAllocated()) {
          PyErr_SetString(PyExc_TypeError,"list must contain strings and blubby");
          free(arg2);
          return nullptr;
        }
        
        arg2[i] = const_cast<char*>(py_str.GetString().data());
      }
      arg2[i] = 0;
    } else if (swig_obj[1] == Py_None) {
      arg2 =  NULL;
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "5"" of type '" "lldb::LanguageType""'");
  } 
  arg5 = static_cast< lldb::LanguageType >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[4], &argp6, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "6"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "6"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg6 = reinterpret_cast< lldb::SBFileSpecList * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[5], &argp7, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "7"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "7"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg7 = reinterpret_cast< lldb::SBFileSpecList * >(argp7);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByNames((char const **)arg2,arg3,arg4,arg5,(lldb::SBFileSpecList const &)*arg6,(lldb::SBFileSpecList const &)*arg7);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByNames__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char **arg2 = 0 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  lldb::LanguageType arg5 ;
  lldb::addr_t arg6 ;
  lldb::SBFileSpecList *arg7 = 0 ;
  lldb::SBFileSpecList *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned long long val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    using namespace lldb_private;
    /* Check if is a list  */
    if (PythonList::Check(swig_obj[1])) {
      PythonList list(PyRefType::Borrowed, swig_obj[1]);
      arg3 = list.GetSize();
      int i = 0;
      arg2 = (char**)malloc((arg3+1)*sizeof(char*));
      for (i = 0; i < arg3; i++) {
        PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
        if (!py_str.IsAllocated()) {
          PyErr_SetString(PyExc_TypeError,"list must contain strings and blubby");
          free(arg2);
          return nullptr;
        }
        
        arg2[i] = const_cast<char*>(py_str.GetString().data());
      }
      arg2[i] = 0;
    } else if (swig_obj[1] == Py_None) {
      arg2 =  NULL;
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "5"" of type '" "lldb::LanguageType""'");
  } 
  arg5 = static_cast< lldb::LanguageType >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "6"" of type '" "lldb::addr_t""'");
  } 
  arg6 = static_cast< lldb::addr_t >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[5], &argp7, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "7"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "7"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg7 = reinterpret_cast< lldb::SBFileSpecList * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[6], &argp8, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "8"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByNames" "', argument " "8"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg8 = reinterpret_cast< lldb::SBFileSpecList * >(argp8);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByNames((char const **)arg2,arg3,arg4,arg5,arg6,(lldb::SBFileSpecList const &)*arg7,(lldb::SBFileSpecList const &)*arg8);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByNames(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_BreakpointCreateByNames", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* Check if is a list  */
        _v = 1;
        if (PythonList::Check(argv[1])) {
          PythonList list(PyRefType::Borrowed, argv[1]);
          int size = list.GetSize();
          int i = 0;
          for (i = 0; i < size; i++) {
            PythonString s = list.GetItemAtIndex(i).AsType<PythonString>();
            if (!s.IsAllocated()) {
              _v = 0;
            }
          }
        } else {
          _v = ((argv[1] == Py_None) ? 1 : 0);
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SBTarget_BreakpointCreateByNames__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* Check if is a list  */
        _v = 1;
        if (PythonList::Check(argv[1])) {
          PythonList list(PyRefType::Borrowed, argv[1]);
          int size = list.GetSize();
          int i = 0;
          for (i = 0; i < size; i++) {
            PythonString s = list.GetItemAtIndex(i).AsType<PythonString>();
            if (!s.IsAllocated()) {
              _v = 0;
            }
          }
        } else {
          _v = ((argv[1] == Py_None) ? 1 : 0);
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_SBTarget_BreakpointCreateByNames__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* Check if is a list  */
        _v = 1;
        if (PythonList::Check(argv[1])) {
          PythonList list(PyRefType::Borrowed, argv[1]);
          int size = list.GetSize();
          int i = 0;
          for (i = 0; i < size; i++) {
            PythonString s = list.GetItemAtIndex(i).AsType<PythonString>();
            if (!s.IsAllocated()) {
              _v = 0;
            }
          }
        } else {
          _v = ((argv[1] == Py_None) ? 1 : 0);
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_SBTarget_BreakpointCreateByNames__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_BreakpointCreateByNames'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::BreakpointCreateByNames(char const **,uint32_t,uint32_t,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n"
    "    lldb::SBTarget::BreakpointCreateByNames(char const **,uint32_t,uint32_t,lldb::LanguageType,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n"
    "    lldb::SBTarget::BreakpointCreateByNames(char const **,uint32_t,uint32_t,lldb::LanguageType,lldb::addr_t,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByRegex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByRegex((char const *)arg2,(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByRegex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByRegex((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByRegex__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBFileSpecList *arg3 = 0 ;
  lldb::SBFileSpecList *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "3"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "3"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpecList * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "4"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "4"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBFileSpecList * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByRegex((char const *)arg2,(lldb::SBFileSpecList const &)*arg3,(lldb::SBFileSpecList const &)*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByRegex__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::LanguageType arg3 ;
  lldb::SBFileSpecList *arg4 = 0 ;
  lldb::SBFileSpecList *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "3"" of type '" "lldb::LanguageType""'");
  } 
  arg3 = static_cast< lldb::LanguageType >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "4"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "4"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBFileSpecList * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "5"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateByRegex" "', argument " "5"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBFileSpecList * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByRegex((char const *)arg2,arg3,(lldb::SBFileSpecList const &)*arg4,(lldb::SBFileSpecList const &)*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByRegex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_BreakpointCreateByRegex", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBTarget_BreakpointCreateByRegex__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBTarget_BreakpointCreateByRegex__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBTarget_BreakpointCreateByRegex__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SBTarget_BreakpointCreateByRegex__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_BreakpointCreateByRegex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::BreakpointCreateByRegex(char const *,char const *)\n"
    "    lldb::SBTarget::BreakpointCreateByRegex(char const *)\n"
    "    lldb::SBTarget::BreakpointCreateByRegex(char const *,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n"
    "    lldb::SBTarget::BreakpointCreateByRegex(char const *,lldb::LanguageType,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBFileSpec *arg3 = 0 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpec * >(argp3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateBySourceRegex((char const *)arg2,(lldb::SBFileSpec const &)*arg3,(char const *)arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBFileSpec *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpec * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateBySourceRegex((char const *)arg2,(lldb::SBFileSpec const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBFileSpecList *arg3 = 0 ;
  lldb::SBFileSpecList *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "3"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "3"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpecList * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "4"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "4"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBFileSpecList * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateBySourceRegex((char const *)arg2,(lldb::SBFileSpecList const &)*arg3,(lldb::SBFileSpecList const &)*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBFileSpecList *arg3 = 0 ;
  lldb::SBFileSpecList *arg4 = 0 ;
  lldb::SBStringList *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "3"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "3"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpecList * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "4"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "4"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBFileSpecList * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBStringList,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "5"" of type '" "lldb::SBStringList const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateBySourceRegex" "', argument " "5"" of type '" "lldb::SBStringList const &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBStringList * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateBySourceRegex((char const *)arg2,(lldb::SBFileSpecList const &)*arg3,(lldb::SBFileSpecList const &)*arg4,(lldb::SBStringList const &)*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateBySourceRegex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_BreakpointCreateBySourceRegex", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_BreakpointCreateBySourceRegex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::BreakpointCreateBySourceRegex(char const *,lldb::SBFileSpec const &,char const *)\n"
    "    lldb::SBTarget::BreakpointCreateBySourceRegex(char const *,lldb::SBFileSpec const &)\n"
    "    lldb::SBTarget::BreakpointCreateBySourceRegex(char const *,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n"
    "    lldb::SBTarget::BreakpointCreateBySourceRegex(char const *,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &,lldb::SBStringList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateForException(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::LanguageType arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_BreakpointCreateForException", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateForException" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_BreakpointCreateForException" "', argument " "2"" of type '" "lldb::LanguageType""'");
  } 
  arg2 = static_cast< lldb::LanguageType >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_BreakpointCreateForException" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBTarget_BreakpointCreateForException" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateForException(arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateByAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::addr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_BreakpointCreateByAddress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateByAddress" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_BreakpointCreateByAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateByAddress(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateBySBAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBAddress *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_BreakpointCreateBySBAddress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateBySBAddress" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateBySBAddress" "', argument " "2"" of type '" "lldb::SBAddress &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateBySBAddress" "', argument " "2"" of type '" "lldb::SBAddress &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAddress * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateBySBAddress(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateFromScript__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBStructuredData *arg3 = 0 ;
  lldb::SBFileSpecList *arg4 = 0 ;
  lldb::SBFileSpecList *arg5 = 0 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStructuredData,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBStructuredData * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "4"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "4"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBFileSpecList * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "5"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "5"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBFileSpecList * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateFromScript((char const *)arg2,*arg3,(lldb::SBFileSpecList const &)*arg4,(lldb::SBFileSpecList const &)*arg5,arg6);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateFromScript__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBStructuredData *arg3 = 0 ;
  lldb::SBFileSpecList *arg4 = 0 ;
  lldb::SBFileSpecList *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStructuredData,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBStructuredData * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "4"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "4"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBFileSpecList * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBFileSpecList,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "5"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointCreateFromScript" "', argument " "5"" of type '" "lldb::SBFileSpecList const &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBFileSpecList * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointCreateFromScript((char const *)arg2,*arg3,(lldb::SBFileSpecList const &)*arg4,(lldb::SBFileSpecList const &)*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointCreateFromScript(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_BreakpointCreateFromScript", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SBTarget_BreakpointCreateFromScript__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SBTarget_BreakpointCreateFromScript__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_BreakpointCreateFromScript'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::BreakpointCreateFromScript(char const *,lldb::SBStructuredData &,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &,bool)\n"
    "    lldb::SBTarget::BreakpointCreateFromScript(char const *,lldb::SBStructuredData &,lldb::SBFileSpecList const &,lldb::SBFileSpecList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsCreateFromFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  lldb::SBBreakpointList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointsCreateFromFile" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointsCreateFromFile" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointsCreateFromFile" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBBreakpointList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_BreakpointsCreateFromFile" "', argument " "3"" of type '" "lldb::SBBreakpointList &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointsCreateFromFile" "', argument " "3"" of type '" "lldb::SBBreakpointList &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBBreakpointList * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointsCreateFromFile(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsCreateFromFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  lldb::SBStringList *arg3 = 0 ;
  lldb::SBBreakpointList *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointsCreateFromFile" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointsCreateFromFile" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointsCreateFromFile" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStringList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_BreakpointsCreateFromFile" "', argument " "3"" of type '" "lldb::SBStringList &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointsCreateFromFile" "', argument " "3"" of type '" "lldb::SBStringList &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBStringList * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBBreakpointList,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_BreakpointsCreateFromFile" "', argument " "4"" of type '" "lldb::SBBreakpointList &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointsCreateFromFile" "', argument " "4"" of type '" "lldb::SBBreakpointList &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBBreakpointList * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointsCreateFromFile(*arg2,*arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsCreateFromFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_BreakpointsCreateFromFile", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBTarget_BreakpointsCreateFromFile__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBTarget_BreakpointsCreateFromFile__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_BreakpointsCreateFromFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::BreakpointsCreateFromFile(lldb::SBFileSpec &,lldb::SBBreakpointList &)\n"
    "    lldb::SBTarget::BreakpointsCreateFromFile(lldb::SBFileSpec &,lldb::SBStringList &,lldb::SBBreakpointList &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsWriteToFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointsWriteToFile" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointsWriteToFile" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointsWriteToFile" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointsWriteToFile(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsWriteToFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  lldb::SBBreakpointList *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointsWriteToFile" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointsWriteToFile" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointsWriteToFile" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBBreakpointList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_BreakpointsWriteToFile" "', argument " "3"" of type '" "lldb::SBBreakpointList &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointsWriteToFile" "', argument " "3"" of type '" "lldb::SBBreakpointList &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBBreakpointList * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBTarget_BreakpointsWriteToFile" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointsWriteToFile(*arg2,*arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsWriteToFile__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  lldb::SBBreakpointList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointsWriteToFile" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_BreakpointsWriteToFile" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointsWriteToFile" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBBreakpointList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_BreakpointsWriteToFile" "', argument " "3"" of type '" "lldb::SBBreakpointList &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_BreakpointsWriteToFile" "', argument " "3"" of type '" "lldb::SBBreakpointList &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBBreakpointList * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->BreakpointsWriteToFile(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointsWriteToFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_BreakpointsWriteToFile", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBTarget_BreakpointsWriteToFile__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBTarget_BreakpointsWriteToFile__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBTarget_BreakpointsWriteToFile__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_BreakpointsWriteToFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::BreakpointsWriteToFile(lldb::SBFileSpec &)\n"
    "    lldb::SBTarget::BreakpointsWriteToFile(lldb::SBFileSpec &,lldb::SBBreakpointList &,bool)\n"
    "    lldb::SBTarget::BreakpointsWriteToFile(lldb::SBFileSpec &,lldb::SBBreakpointList &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetNumBreakpoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetNumBreakpoints" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBTarget const *)arg1)->GetNumBreakpoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetBreakpointAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_GetBreakpointAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetBreakpointAtIndex" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_GetBreakpointAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBTarget const *)arg1)->GetBreakpointAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_BreakpointDelete(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::break_id_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_BreakpointDelete", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_BreakpointDelete" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_BreakpointDelete" "', argument " "2"" of type '" "lldb::break_id_t""'");
  } 
  arg2 = static_cast< lldb::break_id_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->BreakpointDelete(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindBreakpointByID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::break_id_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBBreakpoint result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_FindBreakpointByID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_FindBreakpointByID" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_FindBreakpointByID" "', argument " "2"" of type '" "lldb::break_id_t""'");
  } 
  arg2 = static_cast< lldb::break_id_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindBreakpointByID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(result)), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindBreakpointsByName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBBreakpointList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_FindBreakpointsByName", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_FindBreakpointsByName" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_FindBreakpointsByName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBBreakpointList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_FindBreakpointsByName" "', argument " "3"" of type '" "lldb::SBBreakpointList &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_FindBreakpointsByName" "', argument " "3"" of type '" "lldb::SBBreakpointList &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBBreakpointList * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->FindBreakpointsByName((char const *)arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetBreakpointNames(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBStringList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_GetBreakpointNames", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetBreakpointNames" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_GetBreakpointNames" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_GetBreakpointNames" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->GetBreakpointNames(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_DeleteBreakpointName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_DeleteBreakpointName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_DeleteBreakpointName" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_DeleteBreakpointName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->DeleteBreakpointName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_EnableAllBreakpoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_EnableAllBreakpoints" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->EnableAllBreakpoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_DisableAllBreakpoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_DisableAllBreakpoints" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->DisableAllBreakpoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_DeleteAllBreakpoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_DeleteAllBreakpoints" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->DeleteAllBreakpoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetNumWatchpoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetNumWatchpoints" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBTarget const *)arg1)->GetNumWatchpoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetWatchpointAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBWatchpoint result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_GetWatchpointAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetWatchpointAtIndex" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_GetWatchpointAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBTarget const *)arg1)->GetWatchpointAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBWatchpoint(result)), SWIGTYPE_p_lldb__SBWatchpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_DeleteWatchpoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::watch_id_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_DeleteWatchpoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_DeleteWatchpoint" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_DeleteWatchpoint" "', argument " "2"" of type '" "lldb::watch_id_t""'");
  } 
  arg2 = static_cast< lldb::watch_id_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->DeleteWatchpoint(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindWatchpointByID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::watch_id_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBWatchpoint result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_FindWatchpointByID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_FindWatchpointByID" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_FindWatchpointByID" "', argument " "2"" of type '" "lldb::watch_id_t""'");
  } 
  arg2 = static_cast< lldb::watch_id_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindWatchpointByID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBWatchpoint(result)), SWIGTYPE_p_lldb__SBWatchpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_WatchAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::addr_t arg2 ;
  size_t arg3 ;
  bool arg4 ;
  bool arg5 ;
  lldb::SBError *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  lldb::SBWatchpoint result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_WatchAddress", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_WatchAddress" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_WatchAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_WatchAddress" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBTarget_WatchAddress" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBTarget_WatchAddress" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SBTarget_WatchAddress" "', argument " "6"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_WatchAddress" "', argument " "6"" of type '" "lldb::SBError &""'"); 
  }
  arg6 = reinterpret_cast< lldb::SBError * >(argp6);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->WatchAddress(arg2,SWIG_STD_MOVE(arg3),arg4,arg5,*arg6);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBWatchpoint(result)), SWIGTYPE_p_lldb__SBWatchpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_WatchpointCreateByAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::addr_t arg2 ;
  size_t arg3 ;
  lldb::SBWatchpointOptions arg4 ;
  lldb::SBError *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  lldb::SBWatchpoint result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_WatchpointCreateByAddress", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_WatchpointCreateByAddress" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_WatchpointCreateByAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_WatchpointCreateByAddress" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBWatchpointOptions,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_WatchpointCreateByAddress" "', argument " "4"" of type '" "lldb::SBWatchpointOptions""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_WatchpointCreateByAddress" "', argument " "4"" of type '" "lldb::SBWatchpointOptions""'");
    } else {
      lldb::SBWatchpointOptions * temp = reinterpret_cast< lldb::SBWatchpointOptions * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBTarget_WatchpointCreateByAddress" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_WatchpointCreateByAddress" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBError * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->WatchpointCreateByAddress(arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBWatchpoint(result)), SWIGTYPE_p_lldb__SBWatchpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_EnableAllWatchpoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_EnableAllWatchpoints" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->EnableAllWatchpoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_DisableAllWatchpoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_DisableAllWatchpoints" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->DisableAllWatchpoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_DeleteAllWatchpoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_DeleteAllWatchpoints" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->DeleteAllWatchpoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetBroadcaster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBBroadcaster result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetBroadcaster" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBTarget const *)arg1)->GetBroadcaster();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBBroadcaster(result)), SWIGTYPE_p_lldb__SBBroadcaster, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindFirstType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_FindFirstType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_FindFirstType" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_FindFirstType" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindFirstType((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindTypes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeList result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_FindTypes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_FindTypes" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_FindTypes" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindTypes((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeList(result)), SWIGTYPE_p_lldb__SBTypeList, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetBasicType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::BasicType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_GetBasicType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetBasicType" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_GetBasicType" "', argument " "2"" of type '" "lldb::BasicType""'");
  } 
  arg2 = static_cast< lldb::BasicType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetBasicType(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_CreateValueFromAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBAddress arg3 ;
  lldb::SBType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_CreateValueFromAddress", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_CreateValueFromAddress" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_CreateValueFromAddress" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_CreateValueFromAddress" "', argument " "3"" of type '" "lldb::SBAddress""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_CreateValueFromAddress" "', argument " "3"" of type '" "lldb::SBAddress""'");
    } else {
      lldb::SBAddress * temp = reinterpret_cast< lldb::SBAddress * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBType,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_CreateValueFromAddress" "', argument " "4"" of type '" "lldb::SBType""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_CreateValueFromAddress" "', argument " "4"" of type '" "lldb::SBType""'");
    } else {
      lldb::SBType * temp = reinterpret_cast< lldb::SBType * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateValueFromAddress((char const *)arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_CreateValueFromData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBData arg3 ;
  lldb::SBType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_CreateValueFromData", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_CreateValueFromData" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_CreateValueFromData" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBData,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_CreateValueFromData" "', argument " "3"" of type '" "lldb::SBData""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_CreateValueFromData" "', argument " "3"" of type '" "lldb::SBData""'");
    } else {
      lldb::SBData * temp = reinterpret_cast< lldb::SBData * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBType,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_CreateValueFromData" "', argument " "4"" of type '" "lldb::SBType""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_CreateValueFromData" "', argument " "4"" of type '" "lldb::SBType""'");
    } else {
      lldb::SBType * temp = reinterpret_cast< lldb::SBType * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateValueFromData((char const *)arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_CreateValueFromExpression(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_CreateValueFromExpression", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_CreateValueFromExpression" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_CreateValueFromExpression" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_CreateValueFromExpression" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateValueFromExpression((char const *)arg2,(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetSourceManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< lldb::SBSourceManager > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetSourceManager" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSourceManager();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSourceManager(result)), SWIGTYPE_p_lldb__SBSourceManager, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_ReadInstructions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBAddress arg2 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  lldb::SBInstructionList result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_ReadInstructions" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_ReadInstructions" "', argument " "2"" of type '" "lldb::SBAddress""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_ReadInstructions" "', argument " "2"" of type '" "lldb::SBAddress""'");
    } else {
      lldb::SBAddress * temp = reinterpret_cast< lldb::SBAddress * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_ReadInstructions" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ReadInstructions(SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBInstructionList(result)), SWIGTYPE_p_lldb__SBInstructionList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_ReadInstructions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBAddress arg2 ;
  uint32_t arg3 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  lldb::SBInstructionList result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_ReadInstructions" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_ReadInstructions" "', argument " "2"" of type '" "lldb::SBAddress""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_ReadInstructions" "', argument " "2"" of type '" "lldb::SBAddress""'");
    } else {
      lldb::SBAddress * temp = reinterpret_cast< lldb::SBAddress * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_ReadInstructions" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_ReadInstructions" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ReadInstructions(SWIG_STD_MOVE(arg2),arg3,(char const *)arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBInstructionList(result)), SWIGTYPE_p_lldb__SBInstructionList, SWIG_POINTER_OWN |  0 );
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_ReadInstructions__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBAddress arg2 ;
  lldb::SBAddress arg3 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  lldb::SBInstructionList result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_ReadInstructions" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_ReadInstructions" "', argument " "2"" of type '" "lldb::SBAddress""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_ReadInstructions" "', argument " "2"" of type '" "lldb::SBAddress""'");
    } else {
      lldb::SBAddress * temp = reinterpret_cast< lldb::SBAddress * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_ReadInstructions" "', argument " "3"" of type '" "lldb::SBAddress""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_ReadInstructions" "', argument " "3"" of type '" "lldb::SBAddress""'");
    } else {
      lldb::SBAddress * temp = reinterpret_cast< lldb::SBAddress * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_ReadInstructions" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ReadInstructions(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(char const *)arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBInstructionList(result)), SWIGTYPE_p_lldb__SBInstructionList, SWIG_POINTER_OWN |  0 );
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_ReadInstructions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_ReadInstructions", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBTarget_ReadInstructions__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBTarget_ReadInstructions__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBTarget_ReadInstructions__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_ReadInstructions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::ReadInstructions(lldb::SBAddress,uint32_t)\n"
    "    lldb::SBTarget::ReadInstructions(lldb::SBAddress,uint32_t,char const *)\n"
    "    lldb::SBTarget::ReadInstructions(lldb::SBAddress,lldb::SBAddress,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetInstructions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBAddress arg2 ;
  void *arg3 = 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBInstructionList result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_GetInstructions", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetInstructions" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_GetInstructions" "', argument " "2"" of type '" "lldb::SBAddress""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_GetInstructions" "', argument " "2"" of type '" "lldb::SBAddress""'");
    } else {
      lldb::SBAddress * temp = reinterpret_cast< lldb::SBAddress * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    if (PythonString::Check(swig_obj[2])) {
      PythonString str(PyRefType::Borrowed, swig_obj[2]);
      arg3 = (void *)str.GetString().data();
      arg4 = str.GetSize();
    } else if (PythonByteArray::Check(swig_obj[2])) {
      PythonByteArray bytearray(PyRefType::Borrowed, swig_obj[2]);
      arg3 = (void *)bytearray.GetBytes().data();
      arg4 = bytearray.GetSize();
    } else if (PythonBytes::Check(swig_obj[2])) {
      PythonBytes bytes(PyRefType::Borrowed, swig_obj[2]);
      arg3 = (void *)bytes.GetBytes().data();
      arg4 = bytes.GetSize();
    } else {
      PyErr_SetString(PyExc_ValueError, "Expecting a buffer");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetInstructions(SWIG_STD_MOVE(arg2),(void const *)arg3,SWIG_STD_MOVE(arg4));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBInstructionList(result)), SWIGTYPE_p_lldb__SBInstructionList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetInstructionsWithFlavor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBAddress arg2 ;
  char *arg3 = 0 ;
  void *arg4 = 0 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[4] ;
  lldb::SBInstructionList result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_GetInstructionsWithFlavor", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetInstructionsWithFlavor" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_GetInstructionsWithFlavor" "', argument " "2"" of type '" "lldb::SBAddress""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_GetInstructionsWithFlavor" "', argument " "2"" of type '" "lldb::SBAddress""'");
    } else {
      lldb::SBAddress * temp = reinterpret_cast< lldb::SBAddress * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_GetInstructionsWithFlavor" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    if (PythonString::Check(swig_obj[3])) {
      PythonString str(PyRefType::Borrowed, swig_obj[3]);
      arg4 = (void *)str.GetString().data();
      arg5 = str.GetSize();
    } else if (PythonByteArray::Check(swig_obj[3])) {
      PythonByteArray bytearray(PyRefType::Borrowed, swig_obj[3]);
      arg4 = (void *)bytearray.GetBytes().data();
      arg5 = bytearray.GetSize();
    } else if (PythonBytes::Check(swig_obj[3])) {
      PythonBytes bytes(PyRefType::Borrowed, swig_obj[3]);
      arg4 = (void *)bytes.GetBytes().data();
      arg5 = bytes.GetSize();
    } else {
      PyErr_SetString(PyExc_ValueError, "Expecting a buffer");
      SWIG_fail;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetInstructionsWithFlavor(SWIG_STD_MOVE(arg2),(char const *)arg3,(void const *)arg4,SWIG_STD_MOVE(arg5));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBInstructionList(result)), SWIGTYPE_p_lldb__SBInstructionList, SWIG_POINTER_OWN |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindSymbols__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SymbolType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  lldb::SBSymbolContextList result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_FindSymbols" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_FindSymbols" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_FindSymbols" "', argument " "3"" of type '" "lldb::SymbolType""'");
  } 
  arg3 = static_cast< lldb::SymbolType >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindSymbols((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContextList(result)), SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindSymbols__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBSymbolContextList result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_FindSymbols" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_FindSymbols" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindSymbols((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContextList(result)), SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_FindSymbols(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_FindSymbols", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBTarget_FindSymbols__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBTarget_FindSymbols__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_FindSymbols'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::FindSymbols(char const *,lldb::SymbolType)\n"
    "    lldb::SBTarget::FindSymbols(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBTarget *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget___eq__" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget___eq__" "', argument " "2"" of type '" "lldb::SBTarget const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget___eq__" "', argument " "2"" of type '" "lldb::SBTarget const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTarget const *)arg1)->operator ==((lldb::SBTarget const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBTarget___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBTarget *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget___ne__" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget___ne__" "', argument " "2"" of type '" "lldb::SBTarget const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget___ne__" "', argument " "2"" of type '" "lldb::SBTarget const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTarget const *)arg1)->operator !=((lldb::SBTarget const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::DescriptionLevel arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_GetDescription", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetDescription" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTarget_GetDescription" "', argument " "3"" of type '" "lldb::DescriptionLevel""'");
  } 
  arg3 = static_cast< lldb::DescriptionLevel >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_EvaluateExpression__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_EvaluateExpression" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_EvaluateExpression" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->EvaluateExpression((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_EvaluateExpression__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBExpressionOptions *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_EvaluateExpression" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_EvaluateExpression" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBExpressionOptions,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_EvaluateExpression" "', argument " "3"" of type '" "lldb::SBExpressionOptions const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_EvaluateExpression" "', argument " "3"" of type '" "lldb::SBExpressionOptions const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBExpressionOptions * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->EvaluateExpression((char const *)arg2,(lldb::SBExpressionOptions const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_EvaluateExpression(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTarget_EvaluateExpression", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBTarget_EvaluateExpression__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBTarget_EvaluateExpression__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTarget_EvaluateExpression'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTarget::EvaluateExpression(char const *)\n"
    "    lldb::SBTarget::EvaluateExpression(char const *,lldb::SBExpressionOptions const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetStackRedZoneSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetStackRedZoneSize" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->GetStackRedZoneSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_IsLoaded(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBModule *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_IsLoaded", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_IsLoaded" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBModule,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_IsLoaded" "', argument " "2"" of type '" "lldb::SBModule const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_IsLoaded" "', argument " "2"" of type '" "lldb::SBModule const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBModule * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTarget const *)arg1)->IsLoaded((lldb::SBModule const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetLaunchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< lldb::SBLaunchInfo > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetLaunchInfo" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBTarget const *)arg1)->GetLaunchInfo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBLaunchInfo(result)), SWIGTYPE_p_lldb__SBLaunchInfo, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_SetLaunchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBLaunchInfo *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_SetLaunchInfo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_SetLaunchInfo" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBLaunchInfo,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_SetLaunchInfo" "', argument " "2"" of type '" "lldb::SBLaunchInfo const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_SetLaunchInfo" "', argument " "2"" of type '" "lldb::SBLaunchInfo const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBLaunchInfo * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetLaunchInfo((lldb::SBLaunchInfo const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetTrace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTrace result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetTrace" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTrace();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTrace(result)), SWIGTYPE_p_lldb__SBTrace, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_CreateTrace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTrace result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_CreateTrace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_CreateTrace" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_CreateTrace" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_CreateTrace" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateTrace(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTrace(result)), SWIGTYPE_p_lldb__SBTrace, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_GetAPIMutex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBMutex result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_GetAPIMutex" "', argument " "1"" of type '" "lldb::SBTarget const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBTarget const *)arg1)->GetAPIMutex();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBMutex(result)), SWIGTYPE_p_lldb__SBMutex, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_RegisterScriptedFrameProvider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBStructuredData arg3 ;
  lldb::SBError *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_RegisterScriptedFrameProvider", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_RegisterScriptedFrameProvider" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTarget_RegisterScriptedFrameProvider" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStructuredData,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTarget_RegisterScriptedFrameProvider" "', argument " "3"" of type '" "lldb::SBStructuredData""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_RegisterScriptedFrameProvider" "', argument " "3"" of type '" "lldb::SBStructuredData""'");
    } else {
      lldb::SBStructuredData * temp = reinterpret_cast< lldb::SBStructuredData * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBTarget_RegisterScriptedFrameProvider" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTarget_RegisterScriptedFrameProvider" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBError * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->RegisterScriptedFrameProvider((char const *)arg2,SWIG_STD_MOVE(arg3),*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget_RemoveScriptedFrameProvider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTarget_RemoveScriptedFrameProvider", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget_RemoveScriptedFrameProvider" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTarget_RemoveScriptedFrameProvider" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->RemoveScriptedFrameProvider(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTarget___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTarget___repr__" "', argument " "1"" of type '" "lldb::SBTarget *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBTarget___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBTarget, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBThread_GetBroadcasterClassName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThread_GetBroadcasterClassName", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)lldb::SBThread::GetBroadcasterClassName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBThread__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBThread *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBThread *)new lldb::SBThread();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBThread__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBThread *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBThread,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBThread" "', argument " "1"" of type '" "lldb::SBThread const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBThread" "', argument " "1"" of type '" "lldb::SBThread const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBThread *)new lldb::SBThread((lldb::SBThread const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBThread(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBThread", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBThread__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBThread__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBThread'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThread::SBThread()\n"
    "    lldb::SBThread::SBThread(lldb::SBThread const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBThread" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetQueue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBQueue result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetQueue" "', argument " "1"" of type '" "lldb::SBThread const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBThread const *)arg1)->GetQueue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBQueue(result)), SWIGTYPE_p_lldb__SBQueue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread___nonzero__" "', argument " "1"" of type '" "lldb::SBThread const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBThread const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_IsValid" "', argument " "1"" of type '" "lldb::SBThread const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBThread const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_Clear" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetStopReason(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::StopReason result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetStopReason" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::StopReason)(arg1)->GetStopReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetStopReasonDataCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetStopReasonDataCount" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetStopReasonDataCount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetStopReasonDataAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  uint64_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThread_GetStopReasonDataAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetStopReasonDataAtIndex" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThread_GetStopReasonDataAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetStopReasonDataAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetStopReasonExtendedInfoAsJSON(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThread_GetStopReasonExtendedInfoAsJSON", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetStopReasonExtendedInfoAsJSON" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_GetStopReasonExtendedInfoAsJSON" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_GetStopReasonExtendedInfoAsJSON" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetStopReasonExtendedInfoAsJSON(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetStopReasonExtendedBacktraces(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::InstrumentationRuntimeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBThreadCollection result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThread_GetStopReasonExtendedBacktraces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetStopReasonExtendedBacktraces" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThread_GetStopReasonExtendedBacktraces" "', argument " "2"" of type '" "lldb::InstrumentationRuntimeType""'");
  } 
  arg2 = static_cast< lldb::InstrumentationRuntimeType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetStopReasonExtendedBacktraces(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThreadCollection(result)), SWIGTYPE_p_lldb__SBThreadCollection, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetStopDescription__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetStopDescription" "', argument " "1"" of type '" "lldb::SBThread const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_GetStopDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_GetStopDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBThread const *)arg1)->GetStopDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetStopDescription__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  char *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetStopDescription" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    if (!PyLong_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError, "Expecting an integer");
      SWIG_fail;
    }
    arg3 = PyLong_AsLong(swig_obj[1]);
    if (arg3 <= 0) {
      PyErr_SetString(PyExc_ValueError, "Positive integer expected");
      SWIG_fail;
    }
    arg2 = (char *)malloc(arg3);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetStopDescription(arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  {
    Py_XDECREF(resultobj); /* Blow away any previous result */
    llvm::StringRef ref(arg2);
    PythonString string(ref);
    resultobj = string.release();
    free(arg2);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetStopDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThread_GetStopDescription", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBThread_GetStopDescription__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      if (_v) {
        if (argc <= 2) {
          return _wrap_SBThread_GetStopDescription__SWIG_1(self, argc, argv);
        }
        return _wrap_SBThread_GetStopDescription__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThread_GetStopDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThread::GetStopDescription(lldb::SBStream &) const\n"
    "    lldb::SBThread::GetStopDescription(char *,size_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBThread_GetStopReturnValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBValue result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetStopReturnValue" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetStopReturnValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetThreadID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::tid_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetThreadID" "', argument " "1"" of type '" "lldb::SBThread const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::tid_t)((lldb::SBThread const *)arg1)->GetThreadID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetIndexID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetIndexID" "', argument " "1"" of type '" "lldb::SBThread const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBThread const *)arg1)->GetIndexID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetName" "', argument " "1"" of type '" "lldb::SBThread const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBThread const *)arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetQueueName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetQueueName" "', argument " "1"" of type '" "lldb::SBThread const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBThread const *)arg1)->GetQueueName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetQueueID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::queue_id_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetQueueID" "', argument " "1"" of type '" "lldb::SBThread const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::queue_id_t)((lldb::SBThread const *)arg1)->GetQueueID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetInfoItemByPathAsString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBStream *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThread_GetInfoItemByPathAsString", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetInfoItemByPathAsString" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_GetInfoItemByPathAsString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBThread_GetInfoItemByPathAsString" "', argument " "3"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_GetInfoItemByPathAsString" "', argument " "3"" of type '" "lldb::SBStream &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBStream * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetInfoItemByPathAsString((char const *)arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepOver__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::RunMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepOver" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThread_StepOver" "', argument " "2"" of type '" "lldb::RunMode""'");
  } 
  arg2 = static_cast< lldb::RunMode >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->StepOver(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepOver__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepOver" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->StepOver();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepOver__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::RunMode arg2 ;
  lldb::SBError *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepOver" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThread_StepOver" "', argument " "2"" of type '" "lldb::RunMode""'");
  } 
  arg2 = static_cast< lldb::RunMode >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBThread_StepOver" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_StepOver" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBError * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->StepOver(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepOver(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThread_StepOver", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBThread_StepOver__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBThread_StepOver__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBThread_StepOver__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThread_StepOver'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThread::StepOver(lldb::RunMode)\n"
    "    lldb::SBThread::StepOver()\n"
    "    lldb::SBThread::StepOver(lldb::RunMode,lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::RunMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepInto" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThread_StepInto" "', argument " "2"" of type '" "lldb::RunMode""'");
  } 
  arg2 = static_cast< lldb::RunMode >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->StepInto(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepInto" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->StepInto();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::RunMode arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepInto" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_StepInto" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBThread_StepInto" "', argument " "3"" of type '" "lldb::RunMode""'");
  } 
  arg3 = static_cast< lldb::RunMode >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->StepInto((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepInto" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_StepInto" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->StepInto((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  lldb::SBError *arg4 = 0 ;
  lldb::RunMode arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepInto" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_StepInto" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBThread_StepInto" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBThread_StepInto" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_StepInto" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBError * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBThread_StepInto" "', argument " "5"" of type '" "lldb::RunMode""'");
  } 
  arg5 = static_cast< lldb::RunMode >(val5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->StepInto((char const *)arg2,arg3,*arg4,arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepInto__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  lldb::SBError *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepInto" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_StepInto" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBThread_StepInto" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBThread_StepInto" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_StepInto" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBError * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->StepInto((char const *)arg2,arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepInto(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThread_StepInto", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBThread_StepInto__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBThread_StepInto__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBThread_StepInto__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBThread_StepInto__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBThread_StepInto__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SBThread_StepInto__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThread_StepInto'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThread::StepInto(lldb::RunMode)\n"
    "    lldb::SBThread::StepInto()\n"
    "    lldb::SBThread::StepInto(char const *,lldb::RunMode)\n"
    "    lldb::SBThread::StepInto(char const *)\n"
    "    lldb::SBThread::StepInto(char const *,uint32_t,lldb::SBError &,lldb::RunMode)\n"
    "    lldb::SBThread::StepInto(char const *,uint32_t,lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBThread_StepOut__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepOut" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->StepOut();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepOut__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepOut" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_StepOut" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_StepOut" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->StepOut(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepOut(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThread_StepOut", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBThread_StepOut__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBThread_StepOut__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThread_StepOut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThread::StepOut()\n"
    "    lldb::SBThread::StepOut(lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBThread_StepOutOfFrame__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::SBFrame *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepOutOfFrame" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFrame,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_StepOutOfFrame" "', argument " "2"" of type '" "lldb::SBFrame &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_StepOutOfFrame" "', argument " "2"" of type '" "lldb::SBFrame &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFrame * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->StepOutOfFrame(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepOutOfFrame__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::SBFrame *arg2 = 0 ;
  lldb::SBError *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepOutOfFrame" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFrame,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_StepOutOfFrame" "', argument " "2"" of type '" "lldb::SBFrame &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_StepOutOfFrame" "', argument " "2"" of type '" "lldb::SBFrame &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFrame * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBThread_StepOutOfFrame" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_StepOutOfFrame" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBError * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->StepOutOfFrame(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepOutOfFrame(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThread_StepOutOfFrame", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBThread_StepOutOfFrame__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBThread_StepOutOfFrame__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThread_StepOutOfFrame'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThread::StepOutOfFrame(lldb::SBFrame &)\n"
    "    lldb::SBThread::StepOutOfFrame(lldb::SBFrame &,lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBThread_StepInstruction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepInstruction" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThread_StepInstruction" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->StepInstruction(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepInstruction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  bool arg2 ;
  lldb::SBError *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepInstruction" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThread_StepInstruction" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBThread_StepInstruction" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_StepInstruction" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBError * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->StepInstruction(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepInstruction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThread_StepInstruction", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBThread_StepInstruction__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBThread_StepInstruction__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThread_StepInstruction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThread::StepInstruction(bool)\n"
    "    lldb::SBThread::StepInstruction(bool,lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBThread_StepOverUntil(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::SBFrame *arg2 = 0 ;
  lldb::SBFileSpec *arg3 = 0 ;
  uint32_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThread_StepOverUntil", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepOverUntil" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFrame,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_StepOverUntil" "', argument " "2"" of type '" "lldb::SBFrame &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_StepOverUntil" "', argument " "2"" of type '" "lldb::SBFrame &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFrame * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBThread_StepOverUntil" "', argument " "3"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_StepOverUntil" "', argument " "3"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpec * >(argp3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBThread_StepOverUntil" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->StepOverUntil(*arg2,*arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepUsingScriptedThreadPlan" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_StepUsingScriptedThreadPlan" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->StepUsingScriptedThreadPlan((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  char *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepUsingScriptedThreadPlan" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_StepUsingScriptedThreadPlan" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBThread_StepUsingScriptedThreadPlan" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->StepUsingScriptedThreadPlan((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBStructuredData *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_StepUsingScriptedThreadPlan" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_StepUsingScriptedThreadPlan" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStructuredData,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBThread_StepUsingScriptedThreadPlan" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_StepUsingScriptedThreadPlan" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBStructuredData * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBThread_StepUsingScriptedThreadPlan" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->StepUsingScriptedThreadPlan((char const *)arg2,*arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_StepUsingScriptedThreadPlan(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThread_StepUsingScriptedThreadPlan", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThread_StepUsingScriptedThreadPlan'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThread::StepUsingScriptedThreadPlan(char const *)\n"
    "    lldb::SBThread::StepUsingScriptedThreadPlan(char const *,bool)\n"
    "    lldb::SBThread::StepUsingScriptedThreadPlan(char const *,lldb::SBStructuredData &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBThread_JumpToLine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::SBFileSpec *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThread_JumpToLine", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_JumpToLine" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_JumpToLine" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_JumpToLine" "', argument " "2"" of type '" "lldb::SBFileSpec &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFileSpec * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBThread_JumpToLine" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->JumpToLine(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_RunToAddress__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::addr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_RunToAddress" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThread_RunToAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->RunToAddress(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_RunToAddress__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::addr_t arg2 ;
  lldb::SBError *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_RunToAddress" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThread_RunToAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
  } 
  arg2 = static_cast< lldb::addr_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBThread_RunToAddress" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_RunToAddress" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBError * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->RunToAddress(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_RunToAddress(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThread_RunToAddress", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBThread_RunToAddress__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBThread_RunToAddress__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThread_RunToAddress'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThread::RunToAddress(lldb::addr_t)\n"
    "    lldb::SBThread::RunToAddress(lldb::addr_t,lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBThread_ReturnFromFrame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::SBFrame *arg2 = 0 ;
  lldb::SBValue *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThread_ReturnFromFrame", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_ReturnFromFrame" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFrame,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_ReturnFromFrame" "', argument " "2"" of type '" "lldb::SBFrame &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_ReturnFromFrame" "', argument " "2"" of type '" "lldb::SBFrame &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFrame * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBThread_ReturnFromFrame" "', argument " "3"" of type '" "lldb::SBValue &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_ReturnFromFrame" "', argument " "3"" of type '" "lldb::SBValue &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBValue * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->ReturnFromFrame(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_UnwindInnermostExpression(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBError result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_UnwindInnermostExpression" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->UnwindInnermostExpression();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_Suspend__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_Suspend" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->Suspend();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_Suspend__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_Suspend" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_Suspend" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_Suspend" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->Suspend(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_Suspend(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThread_Suspend", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBThread_Suspend__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBThread_Suspend__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThread_Suspend'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThread::Suspend()\n"
    "    lldb::SBThread::Suspend(lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBThread_Resume__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_Resume" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->Resume();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_Resume__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_Resume" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_Resume" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_Resume" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->Resume(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_Resume(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThread_Resume", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBThread_Resume__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBThread_Resume__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThread_Resume'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThread::Resume()\n"
    "    lldb::SBThread::Resume(lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBThread_IsSuspended(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_IsSuspended" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsSuspended();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_IsStopped(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_IsStopped" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsStopped();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetNumFrames(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetNumFrames" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumFrames();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetFrameAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBFrame result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThread_GetFrameAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetFrameAtIndex" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThread_GetFrameAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetFrameAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFrame(result)), SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetFrames(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFrameList result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetFrames" "', argument " "1"" of type '" "lldb::SBThread const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBThread const *)arg1)->GetFrames();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFrameList(result)), SWIGTYPE_p_lldb__SBFrameList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetSelectedFrame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFrame result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetSelectedFrame" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSelectedFrame();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFrame(result)), SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_SetSelectedFrame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBFrame result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThread_SetSelectedFrame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_SetSelectedFrame" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThread_SetSelectedFrame" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SetSelectedFrame(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFrame(result)), SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_EventIsThreadEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_EventIsThreadEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_EventIsThreadEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBThread::EventIsThreadEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetStackFrameFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFrame result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetStackFrameFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_GetStackFrameFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBThread::GetStackFrameFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFrame(result)), SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetThreadFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBThread result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetThreadFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_GetThreadFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBThread::GetThreadFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBProcess result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetProcess" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetProcess();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::SBThread *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThread___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread___eq__" "', argument " "1"" of type '" "lldb::SBThread const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBThread,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread___eq__" "', argument " "2"" of type '" "lldb::SBThread const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread___eq__" "', argument " "2"" of type '" "lldb::SBThread const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBThread * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBThread const *)arg1)->operator ==((lldb::SBThread const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBThread___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::SBThread *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThread___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread___ne__" "', argument " "1"" of type '" "lldb::SBThread const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBThread,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread___ne__" "', argument " "2"" of type '" "lldb::SBThread const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread___ne__" "', argument " "2"" of type '" "lldb::SBThread const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBThread * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBThread const *)arg1)->operator !=((lldb::SBThread const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBThread_GetDescription__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetDescription" "', argument " "1"" of type '" "lldb::SBThread const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBThread const *)arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetDescription__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetDescription" "', argument " "1"" of type '" "lldb::SBThread const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBThread_GetDescription" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBThread const *)arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThread_GetDescription", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBThread_GetDescription__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBThread_GetDescription__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThread_GetDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThread::GetDescription(lldb::SBStream &) const\n"
    "    lldb::SBThread::GetDescription(lldb::SBStream &,bool) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBThread_GetDescriptionWithFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::SBFormat *arg2 = 0 ;
  lldb::SBStream *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBError result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThread_GetDescriptionWithFormat", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetDescriptionWithFormat" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBFormat,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_GetDescriptionWithFormat" "', argument " "2"" of type '" "lldb::SBFormat const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_GetDescriptionWithFormat" "', argument " "2"" of type '" "lldb::SBFormat const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBFormat * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBThread_GetDescriptionWithFormat" "', argument " "3"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_GetDescriptionWithFormat" "', argument " "3"" of type '" "lldb::SBStream &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBStream * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetDescriptionWithFormat((lldb::SBFormat const &)*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetStatus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThread_GetStatus", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetStatus" "', argument " "1"" of type '" "lldb::SBThread const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_GetStatus" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThread_GetStatus" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBThread const *)arg1)->GetStatus(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetExtendedBacktraceThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBThread result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThread_GetExtendedBacktraceThread", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetExtendedBacktraceThread" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThread_GetExtendedBacktraceThread" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetExtendedBacktraceThread((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetExtendedBacktraceOriginatingIndexID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetExtendedBacktraceOriginatingIndexID" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetExtendedBacktraceOriginatingIndexID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetCurrentException(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBValue result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetCurrentException" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetCurrentException();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetCurrentExceptionBacktrace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBThread result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetCurrentExceptionBacktrace" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetCurrentExceptionBacktrace();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_SafeToCallFunctions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_SafeToCallFunctions" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SafeToCallFunctions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread_GetSiginfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBValue result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread_GetSiginfo" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSiginfo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThread___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThread___repr__" "', argument " "1"" of type '" "lldb::SBThread *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBThread___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBThread_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBThread, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBThread_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBThreadCollection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBThreadCollection *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBThreadCollection *)new lldb::SBThreadCollection();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBThreadCollection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBThreadCollection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThreadCollection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBThreadCollection *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBThreadCollection,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBThreadCollection" "', argument " "1"" of type '" "lldb::SBThreadCollection const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBThreadCollection" "', argument " "1"" of type '" "lldb::SBThreadCollection const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadCollection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBThreadCollection *)new lldb::SBThreadCollection((lldb::SBThreadCollection const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBThreadCollection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBThreadCollection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBThreadCollection", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBThreadCollection__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBThreadCollection, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBThreadCollection__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBThreadCollection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThreadCollection::SBThreadCollection()\n"
    "    lldb::SBThreadCollection::SBThreadCollection(lldb::SBThreadCollection const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBThreadCollection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadCollection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadCollection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBThreadCollection" "', argument " "1"" of type '" "lldb::SBThreadCollection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadCollection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadCollection___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadCollection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadCollection___nonzero__" "', argument " "1"" of type '" "lldb::SBThreadCollection const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadCollection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBThreadCollection const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadCollection_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadCollection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadCollection_IsValid" "', argument " "1"" of type '" "lldb::SBThreadCollection const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadCollection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBThreadCollection const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadCollection_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadCollection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadCollection_GetSize" "', argument " "1"" of type '" "lldb::SBThreadCollection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadCollection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadCollection_GetThreadAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadCollection *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBThread result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThreadCollection_GetThreadAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadCollection_GetThreadAtIndex" "', argument " "1"" of type '" "lldb::SBThreadCollection *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadCollection * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThreadCollection_GetThreadAtIndex" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetThreadAtIndex(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBThreadCollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBThreadCollection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBThreadCollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBThreadPlan__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBThreadPlan *)new lldb::SBThreadPlan();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBThreadPlan__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBThreadPlan *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBThreadPlan,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBThreadPlan" "', argument " "1"" of type '" "lldb::SBThreadPlan const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBThreadPlan" "', argument " "1"" of type '" "lldb::SBThreadPlan const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBThreadPlan *)new lldb::SBThreadPlan((lldb::SBThreadPlan const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBThreadPlan__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBThreadPlan *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBThread,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBThreadPlan" "', argument " "1"" of type '" "lldb::SBThread &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBThreadPlan" "', argument " "1"" of type '" "lldb::SBThread &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBThreadPlan" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBThreadPlan *)new lldb::SBThreadPlan(*arg1,(char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_NEW |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBThreadPlan__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThread *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBStructuredData *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBThreadPlan *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBThread,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBThreadPlan" "', argument " "1"" of type '" "lldb::SBThread &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBThreadPlan" "', argument " "1"" of type '" "lldb::SBThread &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThread * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBThreadPlan" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStructuredData,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SBThreadPlan" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBThreadPlan" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBStructuredData * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBThreadPlan *)new lldb::SBThreadPlan(*arg1,(char const *)arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_NEW |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBThreadPlan(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBThreadPlan", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBThreadPlan__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBThreadPlan__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SBThreadPlan__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SBThreadPlan__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBThreadPlan'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThreadPlan::SBThreadPlan()\n"
    "    lldb::SBThreadPlan::SBThreadPlan(lldb::SBThreadPlan const &)\n"
    "    lldb::SBThreadPlan::SBThreadPlan(lldb::SBThread &,char const *)\n"
    "    lldb::SBThreadPlan::SBThreadPlan(lldb::SBThread &,char const *,lldb::SBStructuredData &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBThreadPlan(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBThreadPlan" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan___nonzero__" "', argument " "1"" of type '" "lldb::SBThreadPlan const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBThreadPlan const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_IsValid__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_IsValid" "', argument " "1"" of type '" "lldb::SBThreadPlan const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBThreadPlan const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_Clear" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_GetStopReason(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::StopReason result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_GetStopReason" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::StopReason)(arg1)->GetStopReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_GetStopReasonDataCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_GetStopReasonDataCount" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetStopReasonDataCount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_GetStopReasonDataAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  uint64_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThreadPlan_GetStopReasonDataAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_GetStopReasonDataAtIndex" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThreadPlan_GetStopReasonDataAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetStopReasonDataAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_GetThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBThread result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_GetThread" "', argument " "1"" of type '" "lldb::SBThreadPlan const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBThreadPlan const *)arg1)->GetThread();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThreadPlan_GetDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_GetDescription" "', argument " "1"" of type '" "lldb::SBThreadPlan const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThreadPlan_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThreadPlan_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBThreadPlan const *)arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_SetPlanComplete(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThreadPlan_SetPlanComplete", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_SetPlanComplete" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThreadPlan_SetPlanComplete" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetPlanComplete(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_IsPlanComplete(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_IsPlanComplete" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsPlanComplete();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_IsPlanStale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_IsPlanStale" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsPlanStale();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_IsValid__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_IsValid" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_IsValid(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThreadPlan_IsValid", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThreadPlan, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBThreadPlan_IsValid__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThreadPlan, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBThreadPlan_IsValid__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThreadPlan_IsValid'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThreadPlan::IsValid() const\n"
    "    lldb::SBThreadPlan::IsValid()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_GetStopOthers(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_GetStopOthers" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetStopOthers();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_SetStopOthers(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThreadPlan_SetStopOthers", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_SetStopOthers" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThreadPlan_SetStopOthers" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetStopOthers(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOverRange__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  lldb::SBAddress *arg2 = 0 ;
  lldb::addr_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  lldb::SBThreadPlan result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_QueueThreadPlanForStepOverRange" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThreadPlan_QueueThreadPlanForStepOverRange" "', argument " "2"" of type '" "lldb::SBAddress &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThreadPlan_QueueThreadPlanForStepOverRange" "', argument " "2"" of type '" "lldb::SBAddress &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAddress * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBThreadPlan_QueueThreadPlanForStepOverRange" "', argument " "3"" of type '" "lldb::addr_t""'");
  } 
  arg3 = static_cast< lldb::addr_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->QueueThreadPlanForStepOverRange(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThreadPlan(result)), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOverRange__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  lldb::SBAddress *arg2 = 0 ;
  lldb::addr_t arg3 ;
  lldb::SBError *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  lldb::SBThreadPlan result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_QueueThreadPlanForStepOverRange" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThreadPlan_QueueThreadPlanForStepOverRange" "', argument " "2"" of type '" "lldb::SBAddress &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThreadPlan_QueueThreadPlanForStepOverRange" "', argument " "2"" of type '" "lldb::SBAddress &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAddress * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBThreadPlan_QueueThreadPlanForStepOverRange" "', argument " "3"" of type '" "lldb::addr_t""'");
  } 
  arg3 = static_cast< lldb::addr_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBThreadPlan_QueueThreadPlanForStepOverRange" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThreadPlan_QueueThreadPlanForStepOverRange" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBError * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->QueueThreadPlanForStepOverRange(*arg2,arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThreadPlan(result)), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOverRange(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThreadPlan_QueueThreadPlanForStepOverRange", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThreadPlan, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBThreadPlan_QueueThreadPlanForStepOverRange__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThreadPlan, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBThreadPlan_QueueThreadPlanForStepOverRange__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThreadPlan_QueueThreadPlanForStepOverRange'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThreadPlan::QueueThreadPlanForStepOverRange(lldb::SBAddress &,lldb::addr_t)\n"
    "    lldb::SBThreadPlan::QueueThreadPlanForStepOverRange(lldb::SBAddress &,lldb::addr_t,lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepInRange__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  lldb::SBAddress *arg2 = 0 ;
  lldb::addr_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  lldb::SBThreadPlan result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_QueueThreadPlanForStepInRange" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThreadPlan_QueueThreadPlanForStepInRange" "', argument " "2"" of type '" "lldb::SBAddress &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThreadPlan_QueueThreadPlanForStepInRange" "', argument " "2"" of type '" "lldb::SBAddress &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAddress * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBThreadPlan_QueueThreadPlanForStepInRange" "', argument " "3"" of type '" "lldb::addr_t""'");
  } 
  arg3 = static_cast< lldb::addr_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->QueueThreadPlanForStepInRange(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThreadPlan(result)), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepInRange__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  lldb::SBAddress *arg2 = 0 ;
  lldb::addr_t arg3 ;
  lldb::SBError *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  lldb::SBThreadPlan result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_QueueThreadPlanForStepInRange" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThreadPlan_QueueThreadPlanForStepInRange" "', argument " "2"" of type '" "lldb::SBAddress &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThreadPlan_QueueThreadPlanForStepInRange" "', argument " "2"" of type '" "lldb::SBAddress &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBAddress * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBThreadPlan_QueueThreadPlanForStepInRange" "', argument " "3"" of type '" "lldb::addr_t""'");
  } 
  arg3 = static_cast< lldb::addr_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBThreadPlan_QueueThreadPlanForStepInRange" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThreadPlan_QueueThreadPlanForStepInRange" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBError * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->QueueThreadPlanForStepInRange(*arg2,arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThreadPlan(result)), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepInRange(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThreadPlan_QueueThreadPlanForStepInRange", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThreadPlan, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBThreadPlan_QueueThreadPlanForStepInRange__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThreadPlan, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBThreadPlan_QueueThreadPlanForStepInRange__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThreadPlan_QueueThreadPlanForStepInRange'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThreadPlan::QueueThreadPlanForStepInRange(lldb::SBAddress &,lldb::addr_t)\n"
    "    lldb::SBThreadPlan::QueueThreadPlanForStepInRange(lldb::SBAddress &,lldb::addr_t,lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  uint32_t arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  lldb::SBThreadPlan result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_QueueThreadPlanForStepOut" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThreadPlan_QueueThreadPlanForStepOut" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBThreadPlan_QueueThreadPlanForStepOut" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->QueueThreadPlanForStepOut(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThreadPlan(result)), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  lldb::SBThreadPlan result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_QueueThreadPlanForStepOut" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThreadPlan_QueueThreadPlanForStepOut" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->QueueThreadPlanForStepOut(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThreadPlan(result)), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  uint32_t arg2 ;
  bool arg3 ;
  lldb::SBError *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  lldb::SBThreadPlan result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_QueueThreadPlanForStepOut" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThreadPlan_QueueThreadPlanForStepOut" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBThreadPlan_QueueThreadPlanForStepOut" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBThreadPlan_QueueThreadPlanForStepOut" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThreadPlan_QueueThreadPlanForStepOut" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBError * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->QueueThreadPlanForStepOut(arg2,arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThreadPlan(result)), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepOut(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThreadPlan_QueueThreadPlanForStepOut", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThreadPlan, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThreadPlan, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThreadPlan, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThreadPlan_QueueThreadPlanForStepOut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThreadPlan::QueueThreadPlanForStepOut(uint32_t,bool)\n"
    "    lldb::SBThreadPlan::QueueThreadPlanForStepOut(uint32_t)\n"
    "    lldb::SBThreadPlan::QueueThreadPlanForStepOut(uint32_t,bool,lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepSingleInstruction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  bool arg2 ;
  lldb::SBError *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBThreadPlan result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBThreadPlan_QueueThreadPlanForStepSingleInstruction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_QueueThreadPlanForStepSingleInstruction" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBThreadPlan_QueueThreadPlanForStepSingleInstruction" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBThreadPlan_QueueThreadPlanForStepSingleInstruction" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThreadPlan_QueueThreadPlanForStepSingleInstruction" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBError * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->QueueThreadPlanForStepSingleInstruction(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThreadPlan(result)), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForRunToAddress__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  lldb::SBAddress arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  lldb::SBThreadPlan result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_QueueThreadPlanForRunToAddress" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThreadPlan_QueueThreadPlanForRunToAddress" "', argument " "2"" of type '" "lldb::SBAddress""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThreadPlan_QueueThreadPlanForRunToAddress" "', argument " "2"" of type '" "lldb::SBAddress""'");
    } else {
      lldb::SBAddress * temp = reinterpret_cast< lldb::SBAddress * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->QueueThreadPlanForRunToAddress(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThreadPlan(result)), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForRunToAddress__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  lldb::SBAddress arg2 ;
  lldb::SBError *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBThreadPlan result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_QueueThreadPlanForRunToAddress" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThreadPlan_QueueThreadPlanForRunToAddress" "', argument " "2"" of type '" "lldb::SBAddress""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThreadPlan_QueueThreadPlanForRunToAddress" "', argument " "2"" of type '" "lldb::SBAddress""'");
    } else {
      lldb::SBAddress * temp = reinterpret_cast< lldb::SBAddress * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBThreadPlan_QueueThreadPlanForRunToAddress" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThreadPlan_QueueThreadPlanForRunToAddress" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBError * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->QueueThreadPlanForRunToAddress(SWIG_STD_MOVE(arg2),*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThreadPlan(result)), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForRunToAddress(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThreadPlan_QueueThreadPlanForRunToAddress", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThreadPlan, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBThreadPlan_QueueThreadPlanForRunToAddress__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThreadPlan, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBThreadPlan_QueueThreadPlanForRunToAddress__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThreadPlan_QueueThreadPlanForRunToAddress'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThreadPlan::QueueThreadPlanForRunToAddress(lldb::SBAddress)\n"
    "    lldb::SBThreadPlan::QueueThreadPlanForRunToAddress(lldb::SBAddress,lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBThreadPlan result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_QueueThreadPlanForStepScripted" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThreadPlan_QueueThreadPlanForStepScripted" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->QueueThreadPlanForStepScripted((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThreadPlan(result)), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBError *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBThreadPlan result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_QueueThreadPlanForStepScripted" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThreadPlan_QueueThreadPlanForStepScripted" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBThreadPlan_QueueThreadPlanForStepScripted" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThreadPlan_QueueThreadPlanForStepScripted" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBError * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->QueueThreadPlanForStepScripted((char const *)arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThreadPlan(result)), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBThreadPlan *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBStructuredData *arg3 = 0 ;
  lldb::SBError *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  lldb::SBThreadPlan result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBThreadPlan, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBThreadPlan_QueueThreadPlanForStepScripted" "', argument " "1"" of type '" "lldb::SBThreadPlan *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBThreadPlan * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBThreadPlan_QueueThreadPlanForStepScripted" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStructuredData,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBThreadPlan_QueueThreadPlanForStepScripted" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThreadPlan_QueueThreadPlanForStepScripted" "', argument " "3"" of type '" "lldb::SBStructuredData &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBStructuredData * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBThreadPlan_QueueThreadPlanForStepScripted" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBThreadPlan_QueueThreadPlanForStepScripted" "', argument " "4"" of type '" "lldb::SBError &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBError * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->QueueThreadPlanForStepScripted((char const *)arg2,*arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThreadPlan(result)), SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBThreadPlan_QueueThreadPlanForStepScripted(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBThreadPlan_QueueThreadPlanForStepScripted", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThreadPlan, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThreadPlan, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBThreadPlan, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBThreadPlan_QueueThreadPlanForStepScripted'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBThreadPlan::QueueThreadPlanForStepScripted(char const *)\n"
    "    lldb::SBThreadPlan::QueueThreadPlanForStepScripted(char const *,lldb::SBError &)\n"
    "    lldb::SBThreadPlan::QueueThreadPlanForStepScripted(char const *,lldb::SBStructuredData &,lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *SBThreadPlan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBThreadPlan, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBThreadPlan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBTrace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTrace *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SBTrace", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTrace *)new lldb::SBTrace();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTrace, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTrace_LoadTraceFromFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBError *arg1 = 0 ;
  lldb::SBDebugger *arg2 = 0 ;
  lldb::SBFileSpec *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBTrace result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTrace_LoadTraceFromFile", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTrace_LoadTraceFromFile" "', argument " "1"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTrace_LoadTraceFromFile" "', argument " "1"" of type '" "lldb::SBError &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBError * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBDebugger,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTrace_LoadTraceFromFile" "', argument " "2"" of type '" "lldb::SBDebugger &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTrace_LoadTraceFromFile" "', argument " "2"" of type '" "lldb::SBDebugger &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBDebugger * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTrace_LoadTraceFromFile" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTrace_LoadTraceFromFile" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpec * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBTrace::LoadTraceFromFile(*arg1,*arg2,(lldb::SBFileSpec const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTrace(result)), SWIGTYPE_p_lldb__SBTrace, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTrace_CreateNewCursor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTrace *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::SBThread *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBTraceCursor result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTrace_CreateNewCursor", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTrace_CreateNewCursor" "', argument " "1"" of type '" "lldb::SBTrace *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTrace * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTrace_CreateNewCursor" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTrace_CreateNewCursor" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBThread,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTrace_CreateNewCursor" "', argument " "3"" of type '" "lldb::SBThread &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTrace_CreateNewCursor" "', argument " "3"" of type '" "lldb::SBThread &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBThread * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateNewCursor(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTraceCursor(result)), SWIGTYPE_p_lldb__SBTraceCursor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTrace_SaveToDisk__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTrace *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::SBFileSpec *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  lldb::SBFileSpec result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTrace_SaveToDisk" "', argument " "1"" of type '" "lldb::SBTrace *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTrace * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTrace_SaveToDisk" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTrace_SaveToDisk" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTrace_SaveToDisk" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTrace_SaveToDisk" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpec * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBTrace_SaveToDisk" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SaveToDisk(*arg2,(lldb::SBFileSpec const &)*arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTrace_SaveToDisk__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTrace *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  lldb::SBFileSpec *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBFileSpec result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTrace_SaveToDisk" "', argument " "1"" of type '" "lldb::SBTrace *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTrace * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTrace_SaveToDisk" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTrace_SaveToDisk" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTrace_SaveToDisk" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTrace_SaveToDisk" "', argument " "3"" of type '" "lldb::SBFileSpec const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBFileSpec * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->SaveToDisk(*arg2,(lldb::SBFileSpec const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(result)), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTrace_SaveToDisk(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTrace_SaveToDisk", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTrace, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBTrace_SaveToDisk__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTrace, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBTrace_SaveToDisk__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTrace_SaveToDisk'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTrace::SaveToDisk(lldb::SBError &,lldb::SBFileSpec const &,bool)\n"
    "    lldb::SBTrace::SaveToDisk(lldb::SBError &,lldb::SBFileSpec const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTrace_GetStartConfigurationHelp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTrace *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTrace_GetStartConfigurationHelp" "', argument " "1"" of type '" "lldb::SBTrace *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTrace * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetStartConfigurationHelp();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTrace_Start__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTrace *arg1 = 0 ;
  lldb::SBStructuredData *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTrace_Start" "', argument " "1"" of type '" "lldb::SBTrace *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTrace * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStructuredData,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTrace_Start" "', argument " "2"" of type '" "lldb::SBStructuredData const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTrace_Start" "', argument " "2"" of type '" "lldb::SBStructuredData const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStructuredData * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Start((lldb::SBStructuredData const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTrace_Start__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTrace *arg1 = 0 ;
  lldb::SBThread *arg2 = 0 ;
  lldb::SBStructuredData *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTrace_Start" "', argument " "1"" of type '" "lldb::SBTrace *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTrace * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBThread,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTrace_Start" "', argument " "2"" of type '" "lldb::SBThread const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTrace_Start" "', argument " "2"" of type '" "lldb::SBThread const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBThread * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBStructuredData,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTrace_Start" "', argument " "3"" of type '" "lldb::SBStructuredData const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTrace_Start" "', argument " "3"" of type '" "lldb::SBStructuredData const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBStructuredData * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Start((lldb::SBThread const &)*arg2,(lldb::SBStructuredData const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTrace_Start(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTrace_Start", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTrace, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBTrace_Start__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTrace, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBTrace_Start__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTrace_Start'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTrace::Start(lldb::SBStructuredData const &)\n"
    "    lldb::SBTrace::Start(lldb::SBThread const &,lldb::SBStructuredData const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTrace_Stop__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTrace *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTrace_Stop" "', argument " "1"" of type '" "lldb::SBTrace *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTrace * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Stop();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTrace_Stop__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTrace *arg1 = 0 ;
  lldb::SBThread *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  lldb::SBError result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTrace_Stop" "', argument " "1"" of type '" "lldb::SBTrace *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTrace * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBThread,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTrace_Stop" "', argument " "2"" of type '" "lldb::SBThread const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTrace_Stop" "', argument " "2"" of type '" "lldb::SBThread const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBThread * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Stop((lldb::SBThread const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTrace_Stop(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTrace_Stop", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTrace, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBTrace_Stop__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBTrace, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBTrace_Stop__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTrace_Stop'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTrace::Stop()\n"
    "    lldb::SBTrace::Stop(lldb::SBThread const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTrace___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTrace *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTrace___nonzero__" "', argument " "1"" of type '" "lldb::SBTrace const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTrace * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTrace const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTrace_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTrace *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTrace_IsValid" "', argument " "1"" of type '" "lldb::SBTrace *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTrace * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBTrace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTrace *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTrace, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBTrace" "', argument " "1"" of type '" "lldb::SBTrace *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTrace * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBTrace_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBTrace, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBTrace_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBTraceCursor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SBTraceCursor", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTraceCursor *)new lldb::SBTraceCursor();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTraceCursor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_SetForwards(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTraceCursor_SetForwards", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_SetForwards" "', argument " "1"" of type '" "lldb::SBTraceCursor *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTraceCursor_SetForwards" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetForwards(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_IsForwards(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_IsForwards" "', argument " "1"" of type '" "lldb::SBTraceCursor const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTraceCursor const *)arg1)->IsForwards();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_Next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_Next" "', argument " "1"" of type '" "lldb::SBTraceCursor *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Next();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_HasValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_HasValue" "', argument " "1"" of type '" "lldb::SBTraceCursor const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTraceCursor const *)arg1)->HasValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_GoToId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  lldb::user_id_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTraceCursor_GoToId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_GoToId" "', argument " "1"" of type '" "lldb::SBTraceCursor *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTraceCursor_GoToId" "', argument " "2"" of type '" "lldb::user_id_t""'");
  } 
  arg2 = static_cast< lldb::user_id_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GoToId(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_HasId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  lldb::user_id_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTraceCursor_HasId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_HasId" "', argument " "1"" of type '" "lldb::SBTraceCursor const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTraceCursor_HasId" "', argument " "2"" of type '" "lldb::user_id_t""'");
  } 
  arg2 = static_cast< lldb::user_id_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTraceCursor const *)arg1)->HasId(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_GetId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::user_id_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_GetId" "', argument " "1"" of type '" "lldb::SBTraceCursor const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::user_id_t)((lldb::SBTraceCursor const *)arg1)->GetId();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_Seek(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  int64_t arg2 ;
  lldb::TraceCursorSeekType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTraceCursor_Seek", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_Seek" "', argument " "1"" of type '" "lldb::SBTraceCursor *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTraceCursor_Seek" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = static_cast< int64_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTraceCursor_Seek" "', argument " "3"" of type '" "lldb::TraceCursorSeekType""'");
  } 
  arg3 = static_cast< lldb::TraceCursorSeekType >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->Seek(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_GetItemKind(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::TraceItemKind result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_GetItemKind" "', argument " "1"" of type '" "lldb::SBTraceCursor const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::TraceItemKind)((lldb::SBTraceCursor const *)arg1)->GetItemKind();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_IsError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_IsError" "', argument " "1"" of type '" "lldb::SBTraceCursor const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTraceCursor const *)arg1)->IsError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_GetError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_GetError" "', argument " "1"" of type '" "lldb::SBTraceCursor const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBTraceCursor const *)arg1)->GetError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_IsEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_IsEvent" "', argument " "1"" of type '" "lldb::SBTraceCursor const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTraceCursor const *)arg1)->IsEvent();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_GetEventType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::TraceEvent result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_GetEventType" "', argument " "1"" of type '" "lldb::SBTraceCursor const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::TraceEvent)((lldb::SBTraceCursor const *)arg1)->GetEventType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_GetEventTypeAsString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_GetEventTypeAsString" "', argument " "1"" of type '" "lldb::SBTraceCursor const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBTraceCursor const *)arg1)->GetEventTypeAsString();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_IsInstruction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_IsInstruction" "', argument " "1"" of type '" "lldb::SBTraceCursor const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTraceCursor const *)arg1)->IsInstruction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_GetLoadAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_GetLoadAddress" "', argument " "1"" of type '" "lldb::SBTraceCursor const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)((lldb::SBTraceCursor const *)arg1)->GetLoadAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_GetCPU(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::cpu_id_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_GetCPU" "', argument " "1"" of type '" "lldb::SBTraceCursor const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::cpu_id_t)((lldb::SBTraceCursor const *)arg1)->GetCPU();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor_IsValid" "', argument " "1"" of type '" "lldb::SBTraceCursor const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTraceCursor const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTraceCursor___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTraceCursor___nonzero__" "', argument " "1"" of type '" "lldb::SBTraceCursor const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTraceCursor const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBTraceCursor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTraceCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTraceCursor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBTraceCursor" "', argument " "1"" of type '" "lldb::SBTraceCursor *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTraceCursor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBTraceCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBTraceCursor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBTraceCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBTypeMember__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBTypeMember *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeMember *)new lldb::SBTypeMember();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeMember, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeMember__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTypeMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBTypeMember *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTypeMember,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeMember" "', argument " "1"" of type '" "lldb::SBTypeMember const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBTypeMember" "', argument " "1"" of type '" "lldb::SBTypeMember const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeMember *)new lldb::SBTypeMember((lldb::SBTypeMember const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeMember, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeMember(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBTypeMember", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBTypeMember__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBTypeMember, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTypeMember__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBTypeMember'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeMember::SBTypeMember()\n"
    "    lldb::SBTypeMember::SBTypeMember(lldb::SBTypeMember const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBTypeMember(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMember, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBTypeMember" "', argument " "1"" of type '" "lldb::SBTypeMember *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMember___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMember___nonzero__" "', argument " "1"" of type '" "lldb::SBTypeMember const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeMember const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMember_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMember_IsValid" "', argument " "1"" of type '" "lldb::SBTypeMember const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeMember const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMember_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMember_GetName" "', argument " "1"" of type '" "lldb::SBTypeMember *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMember_GetType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMember_GetType" "', argument " "1"" of type '" "lldb::SBTypeMember *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMember_GetOffsetInBytes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMember_GetOffsetInBytes" "', argument " "1"" of type '" "lldb::SBTypeMember *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetOffsetInBytes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMember_GetOffsetInBits(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMember_GetOffsetInBits" "', argument " "1"" of type '" "lldb::SBTypeMember *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetOffsetInBits();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMember_IsBitfield(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMember_IsBitfield" "', argument " "1"" of type '" "lldb::SBTypeMember *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsBitfield();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMember_GetBitfieldSizeInBits(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMember_GetBitfieldSizeInBits" "', argument " "1"" of type '" "lldb::SBTypeMember *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetBitfieldSizeInBits();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMember_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMember *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::DescriptionLevel arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeMember_GetDescription", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMember_GetDescription" "', argument " "1"" of type '" "lldb::SBTypeMember *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMember * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeMember_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeMember_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTypeMember_GetDescription" "', argument " "3"" of type '" "lldb::DescriptionLevel""'");
  } 
  arg3 = static_cast< lldb::DescriptionLevel >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMember___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMember___repr__" "', argument " "1"" of type '" "lldb::SBTypeMember *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBTypeMember___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBTypeMember_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBTypeMember, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBTypeMember_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBTypeMemberFunction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBTypeMemberFunction *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeMemberFunction *)new lldb::SBTypeMemberFunction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeMemberFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeMemberFunction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTypeMemberFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBTypeMemberFunction *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTypeMemberFunction,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeMemberFunction" "', argument " "1"" of type '" "lldb::SBTypeMemberFunction const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBTypeMemberFunction" "', argument " "1"" of type '" "lldb::SBTypeMemberFunction const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMemberFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeMemberFunction *)new lldb::SBTypeMemberFunction((lldb::SBTypeMemberFunction const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeMemberFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeMemberFunction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBTypeMemberFunction", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBTypeMemberFunction__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBTypeMemberFunction, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTypeMemberFunction__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBTypeMemberFunction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeMemberFunction::SBTypeMemberFunction()\n"
    "    lldb::SBTypeMemberFunction::SBTypeMemberFunction(lldb::SBTypeMemberFunction const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBTypeMemberFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMemberFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMemberFunction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBTypeMemberFunction" "', argument " "1"" of type '" "lldb::SBTypeMemberFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMemberFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMemberFunction___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMemberFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMemberFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMemberFunction___nonzero__" "', argument " "1"" of type '" "lldb::SBTypeMemberFunction const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMemberFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeMemberFunction const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMemberFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMemberFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMemberFunction_IsValid" "', argument " "1"" of type '" "lldb::SBTypeMemberFunction const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMemberFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeMemberFunction const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMemberFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMemberFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMemberFunction_GetName" "', argument " "1"" of type '" "lldb::SBTypeMemberFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMemberFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetDemangledName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMemberFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMemberFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMemberFunction_GetDemangledName" "', argument " "1"" of type '" "lldb::SBTypeMemberFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMemberFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetDemangledName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetMangledName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMemberFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMemberFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMemberFunction_GetMangledName" "', argument " "1"" of type '" "lldb::SBTypeMemberFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMemberFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetMangledName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMemberFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMemberFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMemberFunction_GetType" "', argument " "1"" of type '" "lldb::SBTypeMemberFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMemberFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetReturnType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMemberFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMemberFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMemberFunction_GetReturnType" "', argument " "1"" of type '" "lldb::SBTypeMemberFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMemberFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetReturnType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetNumberOfArguments(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMemberFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMemberFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMemberFunction_GetNumberOfArguments" "', argument " "1"" of type '" "lldb::SBTypeMemberFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMemberFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumberOfArguments();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetArgumentTypeAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMemberFunction *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeMemberFunction_GetArgumentTypeAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMemberFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMemberFunction_GetArgumentTypeAtIndex" "', argument " "1"" of type '" "lldb::SBTypeMemberFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMemberFunction * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeMemberFunction_GetArgumentTypeAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetArgumentTypeAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetKind(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMemberFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::MemberFunctionKind result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMemberFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMemberFunction_GetKind" "', argument " "1"" of type '" "lldb::SBTypeMemberFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMemberFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::MemberFunctionKind)(arg1)->GetKind();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMemberFunction_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMemberFunction *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::DescriptionLevel arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeMemberFunction_GetDescription", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMemberFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMemberFunction_GetDescription" "', argument " "1"" of type '" "lldb::SBTypeMemberFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMemberFunction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeMemberFunction_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeMemberFunction_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTypeMemberFunction_GetDescription" "', argument " "3"" of type '" "lldb::DescriptionLevel""'");
  } 
  arg3 = static_cast< lldb::DescriptionLevel >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeMemberFunction___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeMemberFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeMemberFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeMemberFunction___repr__" "', argument " "1"" of type '" "lldb::SBTypeMemberFunction *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeMemberFunction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBTypeMemberFunction___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBTypeMemberFunction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBTypeMemberFunction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBTypeMemberFunction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBTypeStaticField__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBTypeStaticField *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeStaticField *)new lldb::SBTypeStaticField();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeStaticField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeStaticField__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTypeStaticField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBTypeStaticField *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTypeStaticField,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeStaticField" "', argument " "1"" of type '" "lldb::SBTypeStaticField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBTypeStaticField" "', argument " "1"" of type '" "lldb::SBTypeStaticField const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeStaticField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeStaticField *)new lldb::SBTypeStaticField((lldb::SBTypeStaticField const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeStaticField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeStaticField(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBTypeStaticField", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBTypeStaticField__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBTypeStaticField, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTypeStaticField__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBTypeStaticField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeStaticField::SBTypeStaticField()\n"
    "    lldb::SBTypeStaticField::SBTypeStaticField(lldb::SBTypeStaticField const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBTypeStaticField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeStaticField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeStaticField, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBTypeStaticField" "', argument " "1"" of type '" "lldb::SBTypeStaticField *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeStaticField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeStaticField___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeStaticField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeStaticField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeStaticField___nonzero__" "', argument " "1"" of type '" "lldb::SBTypeStaticField const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeStaticField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeStaticField const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeStaticField_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeStaticField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeStaticField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeStaticField_IsValid" "', argument " "1"" of type '" "lldb::SBTypeStaticField const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeStaticField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeStaticField const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeStaticField_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeStaticField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeStaticField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeStaticField_GetName" "', argument " "1"" of type '" "lldb::SBTypeStaticField *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeStaticField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeStaticField_GetMangledName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeStaticField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeStaticField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeStaticField_GetMangledName" "', argument " "1"" of type '" "lldb::SBTypeStaticField *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeStaticField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetMangledName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeStaticField_GetType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeStaticField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeStaticField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeStaticField_GetType" "', argument " "1"" of type '" "lldb::SBTypeStaticField *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeStaticField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeStaticField_GetConstantValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeStaticField *arg1 = 0 ;
  lldb::SBTarget arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeStaticField_GetConstantValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeStaticField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeStaticField_GetConstantValue" "', argument " "1"" of type '" "lldb::SBTypeStaticField *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeStaticField * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeStaticField_GetConstantValue" "', argument " "2"" of type '" "lldb::SBTarget""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeStaticField_GetConstantValue" "', argument " "2"" of type '" "lldb::SBTarget""'");
    } else {
      lldb::SBTarget * temp = reinterpret_cast< lldb::SBTarget * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetConstantValue(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBTypeStaticField_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBTypeStaticField, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBTypeStaticField_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBType__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBType *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBType *)new lldb::SBType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBType__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBType *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBType,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBType" "', argument " "1"" of type '" "lldb::SBType const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBType" "', argument " "1"" of type '" "lldb::SBType const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBType *)new lldb::SBType((lldb::SBType const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBType", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBType__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBType, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBType__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBType::SBType()\n"
    "    lldb::SBType::SBType(lldb::SBType const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType___nonzero__" "', argument " "1"" of type '" "lldb::SBType const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBType const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_IsValid" "', argument " "1"" of type '" "lldb::SBType const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBType const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetByteSize" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetByteAlign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetByteAlign" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetByteAlign();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_IsPointerType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_IsPointerType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsPointerType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_IsReferenceType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_IsReferenceType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsReferenceType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_IsFunctionType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_IsFunctionType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsFunctionType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_IsPolymorphicClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_IsPolymorphicClass" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsPolymorphicClass();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_IsArrayType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_IsArrayType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsArrayType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_IsVectorType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_IsVectorType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsVectorType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_IsTypedefType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_IsTypedefType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsTypedefType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_IsAnonymousType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_IsAnonymousType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsAnonymousType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_IsScopedEnumerationType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_IsScopedEnumerationType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsScopedEnumerationType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_IsAggregateType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_IsAggregateType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsAggregateType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetPointerType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetPointerType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetPointerType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetPointeeType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetPointeeType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetPointeeType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetReferenceType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetReferenceType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetReferenceType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetTypedefedType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetTypedefedType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTypedefedType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetDereferencedType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetDereferencedType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetDereferencedType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetUnqualifiedType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetUnqualifiedType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetUnqualifiedType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetArrayElementType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetArrayElementType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetArrayElementType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetArrayType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBType_GetArrayType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetArrayType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBType_GetArrayType" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetArrayType(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetVectorElementType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetVectorElementType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetVectorElementType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetCanonicalType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetCanonicalType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetCanonicalType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetEnumerationIntegerType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetEnumerationIntegerType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetEnumerationIntegerType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetBasicType__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::BasicType result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetBasicType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::BasicType)(arg1)->GetBasicType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetBasicType__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  lldb::BasicType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  lldb::SBType result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetBasicType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBType_GetBasicType" "', argument " "2"" of type '" "lldb::BasicType""'");
  } 
  arg2 = static_cast< lldb::BasicType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetBasicType(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetBasicType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBType_GetBasicType", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBType, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBType_GetBasicType__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBType, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBType_GetBasicType__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBType_GetBasicType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBType::GetBasicType()\n"
    "    lldb::SBType::GetBasicType(lldb::BasicType)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBType_GetNumberOfFields(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetNumberOfFields" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumberOfFields();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetNumberOfDirectBaseClasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetNumberOfDirectBaseClasses" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumberOfDirectBaseClasses();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetNumberOfVirtualBaseClasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetNumberOfVirtualBaseClasses" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumberOfVirtualBaseClasses();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetFieldAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeMember result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBType_GetFieldAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetFieldAtIndex" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBType_GetFieldAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetFieldAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeMember(result)), SWIGTYPE_p_lldb__SBTypeMember, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetDirectBaseClassAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeMember result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBType_GetDirectBaseClassAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetDirectBaseClassAtIndex" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBType_GetDirectBaseClassAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetDirectBaseClassAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeMember(result)), SWIGTYPE_p_lldb__SBTypeMember, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetVirtualBaseClassAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeMember result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBType_GetVirtualBaseClassAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetVirtualBaseClassAtIndex" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBType_GetVirtualBaseClassAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetVirtualBaseClassAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeMember(result)), SWIGTYPE_p_lldb__SBTypeMember, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetStaticFieldWithName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeStaticField result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBType_GetStaticFieldWithName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetStaticFieldWithName" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBType_GetStaticFieldWithName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetStaticFieldWithName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeStaticField(result)), SWIGTYPE_p_lldb__SBTypeStaticField, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetEnumMembers(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTypeEnumMemberList result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetEnumMembers" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetEnumMembers();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeEnumMemberList(result)), SWIGTYPE_p_lldb__SBTypeEnumMemberList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetNumberOfTemplateArguments(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetNumberOfTemplateArguments" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumberOfTemplateArguments();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetTemplateArgumentType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBType_GetTemplateArgumentType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetTemplateArgumentType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBType_GetTemplateArgumentType" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTemplateArgumentType(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetTemplateArgumentValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  lldb::SBTarget arg2 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBType_GetTemplateArgumentValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetTemplateArgumentValue" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBType_GetTemplateArgumentValue" "', argument " "2"" of type '" "lldb::SBTarget""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBType_GetTemplateArgumentValue" "', argument " "2"" of type '" "lldb::SBTarget""'");
    } else {
      lldb::SBTarget * temp = reinterpret_cast< lldb::SBTarget * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBType_GetTemplateArgumentValue" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTemplateArgumentValue(SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetTemplateArgumentKind(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::TemplateArgumentKind result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBType_GetTemplateArgumentKind", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetTemplateArgumentKind" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBType_GetTemplateArgumentKind" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::TemplateArgumentKind)(arg1)->GetTemplateArgumentKind(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetFunctionReturnType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetFunctionReturnType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetFunctionReturnType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetFunctionArgumentTypes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTypeList result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetFunctionArgumentTypes" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetFunctionArgumentTypes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeList(result)), SWIGTYPE_p_lldb__SBTypeList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetNumberOfMemberFunctions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetNumberOfMemberFunctions" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumberOfMemberFunctions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetMemberFunctionAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeMemberFunction result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBType_GetMemberFunctionAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetMemberFunctionAtIndex" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBType_GetMemberFunctionAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetMemberFunctionAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeMemberFunction(result)), SWIGTYPE_p_lldb__SBTypeMemberFunction, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBModule result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetModule" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetModule();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBModule(result)), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetName" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetDisplayTypeName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetDisplayTypeName" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetDisplayTypeName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetTypeClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::TypeClass result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetTypeClass" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::TypeClass)(arg1)->GetTypeClass();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_IsTypeComplete(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_IsTypeComplete" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsTypeComplete();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetTypeFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetTypeFlags" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetTypeFlags();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::DescriptionLevel arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBType_GetDescription", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_GetDescription" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBType_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBType_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBType_GetDescription" "', argument " "3"" of type '" "lldb::DescriptionLevel""'");
  } 
  arg3 = static_cast< lldb::DescriptionLevel >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType_FindDirectNestedType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBType_FindDirectNestedType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType_FindDirectNestedType" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBType_FindDirectNestedType" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindDirectNestedType((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBType___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  lldb::SBType *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBType___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType___eq__" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBType,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBType___eq__" "', argument " "2"" of type '" "lldb::SBType &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBType___eq__" "', argument " "2"" of type '" "lldb::SBType &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBType * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator ==(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBType___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  lldb::SBType *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBType___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType___ne__" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBType,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBType___ne__" "', argument " "2"" of type '" "lldb::SBType &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBType___ne__" "', argument " "2"" of type '" "lldb::SBType &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBType * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator !=(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBType___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBType___repr__" "', argument " "1"" of type '" "lldb::SBType *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBType___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBTypeList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBTypeList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeList *)new lldb::SBTypeList();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTypeList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBTypeList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTypeList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeList" "', argument " "1"" of type '" "lldb::SBTypeList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBTypeList" "', argument " "1"" of type '" "lldb::SBTypeList const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeList *)new lldb::SBTypeList((lldb::SBTypeList const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBTypeList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBTypeList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBTypeList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTypeList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBTypeList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeList::SBTypeList()\n"
    "    lldb::SBTypeList::SBTypeList(lldb::SBTypeList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBTypeList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBTypeList" "', argument " "1"" of type '" "lldb::SBTypeList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeList___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeList___nonzero__" "', argument " "1"" of type '" "lldb::SBTypeList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeList const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeList_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeList_IsValid" "', argument " "1"" of type '" "lldb::SBTypeList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeList_Append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeList *arg1 = 0 ;
  lldb::SBType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeList_Append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeList_Append" "', argument " "1"" of type '" "lldb::SBTypeList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeList * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeList_Append" "', argument " "2"" of type '" "lldb::SBType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeList_Append" "', argument " "2"" of type '" "lldb::SBType""'");
    } else {
      lldb::SBType * temp = reinterpret_cast< lldb::SBType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Append(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeList_GetTypeAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeList *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeList_GetTypeAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeList_GetTypeAtIndex" "', argument " "1"" of type '" "lldb::SBTypeList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeList * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeList_GetTypeAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTypeAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeList_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeList_GetSize" "', argument " "1"" of type '" "lldb::SBTypeList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBTypeList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBTypeList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBTypeList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBTypeCategory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeCategory *)new lldb::SBTypeCategory();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeCategory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeCategory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBTypeCategory *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTypeCategory,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeCategory" "', argument " "1"" of type '" "lldb::SBTypeCategory const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBTypeCategory" "', argument " "1"" of type '" "lldb::SBTypeCategory const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeCategory *)new lldb::SBTypeCategory((lldb::SBTypeCategory const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeCategory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeCategory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBTypeCategory", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBTypeCategory__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBTypeCategory, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTypeCategory__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBTypeCategory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeCategory::SBTypeCategory()\n"
    "    lldb::SBTypeCategory::SBTypeCategory(lldb::SBTypeCategory const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBTypeCategory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBTypeCategory" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory___nonzero__" "', argument " "1"" of type '" "lldb::SBTypeCategory const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeCategory const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_IsValid" "', argument " "1"" of type '" "lldb::SBTypeCategory const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeCategory const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetEnabled" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetEnabled();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_SetEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_SetEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_SetEnabled" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeCategory_SetEnabled" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetEnabled(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetName" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetLanguageAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::LanguageType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_GetLanguageAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetLanguageAtIndex" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeCategory_GetLanguageAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::LanguageType)(arg1)->GetLanguageAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetNumLanguages(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetNumLanguages" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumLanguages();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_AddLanguage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  lldb::LanguageType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_AddLanguage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_AddLanguage" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeCategory_AddLanguage" "', argument " "2"" of type '" "lldb::LanguageType""'");
  } 
  arg2 = static_cast< lldb::LanguageType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->AddLanguage(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::DescriptionLevel arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_GetDescription", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetDescription" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeCategory_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTypeCategory_GetDescription" "', argument " "3"" of type '" "lldb::DescriptionLevel""'");
  } 
  arg3 = static_cast< lldb::DescriptionLevel >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetNumFormats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetNumFormats" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumFormats();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetNumSummaries(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetNumSummaries" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumSummaries();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetNumFilters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetNumFilters" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumFilters();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetNumSynthetics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetNumSynthetics" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumSynthetics();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeNameSpecifier result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTypeNameSpecifierForFilterAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeNameSpecifier(result)), SWIGTYPE_p_lldb__SBTypeNameSpecifier, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeNameSpecifier result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTypeNameSpecifierForFormatAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeNameSpecifier(result)), SWIGTYPE_p_lldb__SBTypeNameSpecifier, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeNameSpecifier result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTypeNameSpecifierForSummaryAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeNameSpecifier(result)), SWIGTYPE_p_lldb__SBTypeNameSpecifier, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeNameSpecifier result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTypeNameSpecifierForSyntheticAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeNameSpecifier(result)), SWIGTYPE_p_lldb__SBTypeNameSpecifier, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetFilterForType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  lldb::SBTypeNameSpecifier arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeFilter result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_GetFilterForType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetFilterForType" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeCategory_GetFilterForType" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_GetFilterForType" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'");
    } else {
      lldb::SBTypeNameSpecifier * temp = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetFilterForType(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeFilter(result)), SWIGTYPE_p_lldb__SBTypeFilter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetFormatForType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  lldb::SBTypeNameSpecifier arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeFormat result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_GetFormatForType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetFormatForType" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeCategory_GetFormatForType" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_GetFormatForType" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'");
    } else {
      lldb::SBTypeNameSpecifier * temp = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetFormatForType(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeFormat(result)), SWIGTYPE_p_lldb__SBTypeFormat, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetSummaryForType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  lldb::SBTypeNameSpecifier arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeSummary result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_GetSummaryForType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetSummaryForType" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeCategory_GetSummaryForType" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_GetSummaryForType" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'");
    } else {
      lldb::SBTypeNameSpecifier * temp = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSummaryForType(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSummary(result)), SWIGTYPE_p_lldb__SBTypeSummary, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetSyntheticForType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  lldb::SBTypeNameSpecifier arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeSynthetic result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_GetSyntheticForType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetSyntheticForType" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeCategory_GetSyntheticForType" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_GetSyntheticForType" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'");
    } else {
      lldb::SBTypeNameSpecifier * temp = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSyntheticForType(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSynthetic(result)), SWIGTYPE_p_lldb__SBTypeSynthetic, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetFilterAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeFilter result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_GetFilterAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetFilterAtIndex" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeCategory_GetFilterAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetFilterAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeFilter(result)), SWIGTYPE_p_lldb__SBTypeFilter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetFormatAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeFormat result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_GetFormatAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetFormatAtIndex" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeCategory_GetFormatAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetFormatAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeFormat(result)), SWIGTYPE_p_lldb__SBTypeFormat, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetSummaryAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeSummary result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_GetSummaryAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetSummaryAtIndex" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeCategory_GetSummaryAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSummaryAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSummary(result)), SWIGTYPE_p_lldb__SBTypeSummary, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_GetSyntheticAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeSynthetic result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_GetSyntheticAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_GetSyntheticAtIndex" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeCategory_GetSyntheticAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSyntheticAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSynthetic(result)), SWIGTYPE_p_lldb__SBTypeSynthetic, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_AddTypeFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  lldb::SBTypeNameSpecifier arg2 ;
  lldb::SBTypeFormat arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_AddTypeFormat", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_AddTypeFormat" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeCategory_AddTypeFormat" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_AddTypeFormat" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'");
    } else {
      lldb::SBTypeNameSpecifier * temp = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBTypeFormat,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTypeCategory_AddTypeFormat" "', argument " "3"" of type '" "lldb::SBTypeFormat""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_AddTypeFormat" "', argument " "3"" of type '" "lldb::SBTypeFormat""'");
    } else {
      lldb::SBTypeFormat * temp = reinterpret_cast< lldb::SBTypeFormat * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->AddTypeFormat(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_DeleteTypeFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  lldb::SBTypeNameSpecifier arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_DeleteTypeFormat", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_DeleteTypeFormat" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeCategory_DeleteTypeFormat" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_DeleteTypeFormat" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'");
    } else {
      lldb::SBTypeNameSpecifier * temp = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->DeleteTypeFormat(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_AddTypeSummary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  lldb::SBTypeNameSpecifier arg2 ;
  lldb::SBTypeSummary arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_AddTypeSummary", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_AddTypeSummary" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeCategory_AddTypeSummary" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_AddTypeSummary" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'");
    } else {
      lldb::SBTypeNameSpecifier * temp = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBTypeSummary,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTypeCategory_AddTypeSummary" "', argument " "3"" of type '" "lldb::SBTypeSummary""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_AddTypeSummary" "', argument " "3"" of type '" "lldb::SBTypeSummary""'");
    } else {
      lldb::SBTypeSummary * temp = reinterpret_cast< lldb::SBTypeSummary * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->AddTypeSummary(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_DeleteTypeSummary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  lldb::SBTypeNameSpecifier arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_DeleteTypeSummary", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_DeleteTypeSummary" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeCategory_DeleteTypeSummary" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_DeleteTypeSummary" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'");
    } else {
      lldb::SBTypeNameSpecifier * temp = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->DeleteTypeSummary(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_AddTypeFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  lldb::SBTypeNameSpecifier arg2 ;
  lldb::SBTypeFilter arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_AddTypeFilter", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_AddTypeFilter" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeCategory_AddTypeFilter" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_AddTypeFilter" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'");
    } else {
      lldb::SBTypeNameSpecifier * temp = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBTypeFilter,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTypeCategory_AddTypeFilter" "', argument " "3"" of type '" "lldb::SBTypeFilter""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_AddTypeFilter" "', argument " "3"" of type '" "lldb::SBTypeFilter""'");
    } else {
      lldb::SBTypeFilter * temp = reinterpret_cast< lldb::SBTypeFilter * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->AddTypeFilter(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_DeleteTypeFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  lldb::SBTypeNameSpecifier arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_DeleteTypeFilter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_DeleteTypeFilter" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeCategory_DeleteTypeFilter" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_DeleteTypeFilter" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'");
    } else {
      lldb::SBTypeNameSpecifier * temp = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->DeleteTypeFilter(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_AddTypeSynthetic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  lldb::SBTypeNameSpecifier arg2 ;
  lldb::SBTypeSynthetic arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_AddTypeSynthetic", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_AddTypeSynthetic" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeCategory_AddTypeSynthetic" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_AddTypeSynthetic" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'");
    } else {
      lldb::SBTypeNameSpecifier * temp = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBTypeSynthetic,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTypeCategory_AddTypeSynthetic" "', argument " "3"" of type '" "lldb::SBTypeSynthetic""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_AddTypeSynthetic" "', argument " "3"" of type '" "lldb::SBTypeSynthetic""'");
    } else {
      lldb::SBTypeSynthetic * temp = reinterpret_cast< lldb::SBTypeSynthetic * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->AddTypeSynthetic(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory_DeleteTypeSynthetic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  lldb::SBTypeNameSpecifier arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory_DeleteTypeSynthetic", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory_DeleteTypeSynthetic" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeCategory_DeleteTypeSynthetic" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory_DeleteTypeSynthetic" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier""'");
    } else {
      lldb::SBTypeNameSpecifier * temp = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->DeleteTypeSynthetic(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  lldb::SBTypeCategory *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory___eq__" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeCategory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeCategory___eq__" "', argument " "2"" of type '" "lldb::SBTypeCategory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory___eq__" "', argument " "2"" of type '" "lldb::SBTypeCategory &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeCategory * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator ==(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  lldb::SBTypeCategory *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeCategory___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory___ne__" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeCategory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeCategory___ne__" "', argument " "2"" of type '" "lldb::SBTypeCategory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeCategory___ne__" "', argument " "2"" of type '" "lldb::SBTypeCategory &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeCategory * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator !=(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBTypeCategory___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeCategory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeCategory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeCategory___repr__" "', argument " "1"" of type '" "lldb::SBTypeCategory *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeCategory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBTypeCategory___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBTypeCategory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBTypeCategory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBTypeCategory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBTypeEnumMember__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMember *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeEnumMember *)new lldb::SBTypeEnumMember();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeEnumMember, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeEnumMember__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBTypeEnumMember *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTypeEnumMember,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeEnumMember" "', argument " "1"" of type '" "lldb::SBTypeEnumMember const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBTypeEnumMember" "', argument " "1"" of type '" "lldb::SBTypeEnumMember const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeEnumMember *)new lldb::SBTypeEnumMember((lldb::SBTypeEnumMember const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeEnumMember, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeEnumMember(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBTypeEnumMember", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBTypeEnumMember__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBTypeEnumMember, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTypeEnumMember__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBTypeEnumMember'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeEnumMember::SBTypeEnumMember()\n"
    "    lldb::SBTypeEnumMember::SBTypeEnumMember(lldb::SBTypeEnumMember const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBTypeEnumMember(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeEnumMember, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBTypeEnumMember" "', argument " "1"" of type '" "lldb::SBTypeEnumMember *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeEnumMember___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeEnumMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeEnumMember___nonzero__" "', argument " "1"" of type '" "lldb::SBTypeEnumMember const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeEnumMember const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeEnumMember_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeEnumMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeEnumMember_IsValid" "', argument " "1"" of type '" "lldb::SBTypeEnumMember const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeEnumMember const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeEnumMember_GetValueAsSigned(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeEnumMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeEnumMember_GetValueAsSigned" "', argument " "1"" of type '" "lldb::SBTypeEnumMember *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int64_t)(arg1)->GetValueAsSigned();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeEnumMember_GetValueAsUnsigned(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeEnumMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeEnumMember_GetValueAsUnsigned" "', argument " "1"" of type '" "lldb::SBTypeEnumMember *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetValueAsUnsigned();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeEnumMember_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeEnumMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeEnumMember_GetName" "', argument " "1"" of type '" "lldb::SBTypeEnumMember *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeEnumMember_GetType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeEnumMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeEnumMember_GetType" "', argument " "1"" of type '" "lldb::SBTypeEnumMember *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeEnumMember_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMember *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::DescriptionLevel arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeEnumMember_GetDescription", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeEnumMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeEnumMember_GetDescription" "', argument " "1"" of type '" "lldb::SBTypeEnumMember *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMember * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeEnumMember_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeEnumMember_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTypeEnumMember_GetDescription" "', argument " "3"" of type '" "lldb::DescriptionLevel""'");
  } 
  arg3 = static_cast< lldb::DescriptionLevel >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeEnumMember___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMember *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeEnumMember, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeEnumMember___repr__" "', argument " "1"" of type '" "lldb::SBTypeEnumMember *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMember * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBTypeEnumMember___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBTypeEnumMember_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBTypeEnumMember, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBTypeEnumMember_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBTypeEnumMemberList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMemberList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeEnumMemberList *)new lldb::SBTypeEnumMemberList();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeEnumMemberList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeEnumMemberList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMemberList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBTypeEnumMemberList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTypeEnumMemberList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeEnumMemberList" "', argument " "1"" of type '" "lldb::SBTypeEnumMemberList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBTypeEnumMemberList" "', argument " "1"" of type '" "lldb::SBTypeEnumMemberList const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMemberList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeEnumMemberList *)new lldb::SBTypeEnumMemberList((lldb::SBTypeEnumMemberList const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeEnumMemberList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeEnumMemberList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBTypeEnumMemberList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBTypeEnumMemberList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBTypeEnumMemberList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTypeEnumMemberList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBTypeEnumMemberList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeEnumMemberList::SBTypeEnumMemberList()\n"
    "    lldb::SBTypeEnumMemberList::SBTypeEnumMemberList(lldb::SBTypeEnumMemberList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBTypeEnumMemberList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMemberList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeEnumMemberList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBTypeEnumMemberList" "', argument " "1"" of type '" "lldb::SBTypeEnumMemberList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMemberList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeEnumMemberList___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMemberList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeEnumMemberList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeEnumMemberList___nonzero__" "', argument " "1"" of type '" "lldb::SBTypeEnumMemberList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMemberList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeEnumMemberList const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeEnumMemberList_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMemberList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeEnumMemberList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeEnumMemberList_IsValid" "', argument " "1"" of type '" "lldb::SBTypeEnumMemberList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMemberList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeEnumMemberList_Append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMemberList *arg1 = 0 ;
  lldb::SBTypeEnumMember arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeEnumMemberList_Append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeEnumMemberList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeEnumMemberList_Append" "', argument " "1"" of type '" "lldb::SBTypeEnumMemberList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMemberList * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeEnumMember,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeEnumMemberList_Append" "', argument " "2"" of type '" "lldb::SBTypeEnumMember""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeEnumMemberList_Append" "', argument " "2"" of type '" "lldb::SBTypeEnumMember""'");
    } else {
      lldb::SBTypeEnumMember * temp = reinterpret_cast< lldb::SBTypeEnumMember * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Append(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeEnumMemberList_GetTypeEnumMemberAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMemberList *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBTypeEnumMember result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeEnumMemberList_GetTypeEnumMemberAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeEnumMemberList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeEnumMemberList_GetTypeEnumMemberAtIndex" "', argument " "1"" of type '" "lldb::SBTypeEnumMemberList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMemberList * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeEnumMemberList_GetTypeEnumMemberAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTypeEnumMemberAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeEnumMember(result)), SWIGTYPE_p_lldb__SBTypeEnumMember, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeEnumMemberList_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeEnumMemberList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeEnumMemberList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeEnumMemberList_GetSize" "', argument " "1"" of type '" "lldb::SBTypeEnumMemberList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeEnumMemberList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBTypeEnumMemberList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBTypeEnumMemberList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBTypeEnumMemberList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBTypeFilter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeFilter *)new lldb::SBTypeFilter();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeFilter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeFilter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  lldb::SBTypeFilter *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBTypeFilter" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeFilter *)new lldb::SBTypeFilter(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeFilter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeFilter__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBTypeFilter *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTypeFilter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeFilter" "', argument " "1"" of type '" "lldb::SBTypeFilter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBTypeFilter" "', argument " "1"" of type '" "lldb::SBTypeFilter const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFilter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeFilter *)new lldb::SBTypeFilter((lldb::SBTypeFilter const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeFilter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeFilter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBTypeFilter", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBTypeFilter__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBTypeFilter, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTypeFilter__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SBTypeFilter__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBTypeFilter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeFilter::SBTypeFilter()\n"
    "    lldb::SBTypeFilter::SBTypeFilter(uint32_t)\n"
    "    lldb::SBTypeFilter::SBTypeFilter(lldb::SBTypeFilter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBTypeFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFilter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBTypeFilter" "', argument " "1"" of type '" "lldb::SBTypeFilter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFilter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFilter___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFilter___nonzero__" "', argument " "1"" of type '" "lldb::SBTypeFilter const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFilter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeFilter const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFilter_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFilter_IsValid" "', argument " "1"" of type '" "lldb::SBTypeFilter const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFilter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeFilter const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFilter_GetNumberOfExpressionPaths(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFilter_GetNumberOfExpressionPaths" "', argument " "1"" of type '" "lldb::SBTypeFilter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFilter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumberOfExpressionPaths();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFilter_GetExpressionPathAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeFilter_GetExpressionPathAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFilter_GetExpressionPathAtIndex" "', argument " "1"" of type '" "lldb::SBTypeFilter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFilter * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeFilter_GetExpressionPathAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetExpressionPathAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFilter_ReplaceExpressionPathAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *arg1 = 0 ;
  uint32_t arg2 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeFilter_ReplaceExpressionPathAtIndex", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFilter_ReplaceExpressionPathAtIndex" "', argument " "1"" of type '" "lldb::SBTypeFilter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFilter * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeFilter_ReplaceExpressionPathAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBTypeFilter_ReplaceExpressionPathAtIndex" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->ReplaceExpressionPathAtIndex(arg2,(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFilter_AppendExpressionPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeFilter_AppendExpressionPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFilter_AppendExpressionPath" "', argument " "1"" of type '" "lldb::SBTypeFilter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFilter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeFilter_AppendExpressionPath" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->AppendExpressionPath((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFilter_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFilter_Clear" "', argument " "1"" of type '" "lldb::SBTypeFilter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFilter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFilter_GetOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFilter_GetOptions" "', argument " "1"" of type '" "lldb::SBTypeFilter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFilter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetOptions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFilter_SetOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeFilter_SetOptions", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFilter_SetOptions" "', argument " "1"" of type '" "lldb::SBTypeFilter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFilter * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeFilter_SetOptions" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetOptions(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFilter_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::DescriptionLevel arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeFilter_GetDescription", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFilter_GetDescription" "', argument " "1"" of type '" "lldb::SBTypeFilter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFilter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeFilter_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeFilter_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTypeFilter_GetDescription" "', argument " "3"" of type '" "lldb::DescriptionLevel""'");
  } 
  arg3 = static_cast< lldb::DescriptionLevel >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFilter_IsEqualTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *arg1 = 0 ;
  lldb::SBTypeFilter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeFilter_IsEqualTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFilter_IsEqualTo" "', argument " "1"" of type '" "lldb::SBTypeFilter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFilter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeFilter,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeFilter_IsEqualTo" "', argument " "2"" of type '" "lldb::SBTypeFilter &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeFilter_IsEqualTo" "', argument " "2"" of type '" "lldb::SBTypeFilter &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeFilter * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsEqualTo(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFilter___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *arg1 = 0 ;
  lldb::SBTypeFilter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeFilter___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFilter___eq__" "', argument " "1"" of type '" "lldb::SBTypeFilter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFilter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeFilter,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeFilter___eq__" "', argument " "2"" of type '" "lldb::SBTypeFilter &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeFilter___eq__" "', argument " "2"" of type '" "lldb::SBTypeFilter &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeFilter * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator ==(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBTypeFilter___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *arg1 = 0 ;
  lldb::SBTypeFilter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeFilter___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFilter___ne__" "', argument " "1"" of type '" "lldb::SBTypeFilter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFilter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeFilter,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeFilter___ne__" "', argument " "2"" of type '" "lldb::SBTypeFilter &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeFilter___ne__" "', argument " "2"" of type '" "lldb::SBTypeFilter &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeFilter * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator !=(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBTypeFilter___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFilter___repr__" "', argument " "1"" of type '" "lldb::SBTypeFilter *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFilter * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBTypeFilter___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBTypeFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBTypeFilter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBTypeFilter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBTypeFormat__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBTypeFormat *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeFormat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeFormat__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::Format arg1 ;
  uint32_t arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  lldb::SBTypeFormat *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBTypeFormat" "', argument " "1"" of type '" "lldb::Format""'");
  } 
  arg1 = static_cast< lldb::Format >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBTypeFormat" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat(arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeFormat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeFormat__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::Format arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  lldb::SBTypeFormat *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBTypeFormat" "', argument " "1"" of type '" "lldb::Format""'");
  } 
  arg1 = static_cast< lldb::Format >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeFormat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeFormat__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  uint32_t arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  lldb::SBTypeFormat *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeFormat" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBTypeFormat" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat((char const *)arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeFormat, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeFormat__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  lldb::SBTypeFormat *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeFormat" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeFormat, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeFormat__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTypeFormat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBTypeFormat *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTypeFormat,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeFormat" "', argument " "1"" of type '" "lldb::SBTypeFormat const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBTypeFormat" "', argument " "1"" of type '" "lldb::SBTypeFormat const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFormat * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat((lldb::SBTypeFormat const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeFormat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeFormat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBTypeFormat", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBTypeFormat__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBTypeFormat, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTypeFormat__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SBTypeFormat__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTypeFormat__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SBTypeFormat__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SBTypeFormat__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBTypeFormat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeFormat::SBTypeFormat()\n"
    "    lldb::SBTypeFormat::SBTypeFormat(lldb::Format,uint32_t)\n"
    "    lldb::SBTypeFormat::SBTypeFormat(lldb::Format)\n"
    "    lldb::SBTypeFormat::SBTypeFormat(char const *,uint32_t)\n"
    "    lldb::SBTypeFormat::SBTypeFormat(char const *)\n"
    "    lldb::SBTypeFormat::SBTypeFormat(lldb::SBTypeFormat const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBTypeFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFormat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFormat, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBTypeFormat" "', argument " "1"" of type '" "lldb::SBTypeFormat *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFormat * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFormat___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFormat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFormat___nonzero__" "', argument " "1"" of type '" "lldb::SBTypeFormat const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFormat * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeFormat const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFormat_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFormat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFormat_IsValid" "', argument " "1"" of type '" "lldb::SBTypeFormat const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFormat * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeFormat const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFormat_GetFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFormat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::Format result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFormat_GetFormat" "', argument " "1"" of type '" "lldb::SBTypeFormat *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFormat * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::Format)(arg1)->GetFormat();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFormat_GetTypeName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFormat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFormat_GetTypeName" "', argument " "1"" of type '" "lldb::SBTypeFormat *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFormat * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetTypeName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFormat_GetOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFormat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFormat_GetOptions" "', argument " "1"" of type '" "lldb::SBTypeFormat *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFormat * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetOptions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFormat_SetFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFormat *arg1 = 0 ;
  lldb::Format arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeFormat_SetFormat", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFormat_SetFormat" "', argument " "1"" of type '" "lldb::SBTypeFormat *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFormat * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeFormat_SetFormat" "', argument " "2"" of type '" "lldb::Format""'");
  } 
  arg2 = static_cast< lldb::Format >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetFormat(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFormat_SetTypeName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFormat *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeFormat_SetTypeName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFormat_SetTypeName" "', argument " "1"" of type '" "lldb::SBTypeFormat *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFormat * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeFormat_SetTypeName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetTypeName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFormat_SetOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFormat *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeFormat_SetOptions", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFormat_SetOptions" "', argument " "1"" of type '" "lldb::SBTypeFormat *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeFormat_SetOptions" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetOptions(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFormat_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFormat *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::DescriptionLevel arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeFormat_GetDescription", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFormat_GetDescription" "', argument " "1"" of type '" "lldb::SBTypeFormat *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFormat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeFormat_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeFormat_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTypeFormat_GetDescription" "', argument " "3"" of type '" "lldb::DescriptionLevel""'");
  } 
  arg3 = static_cast< lldb::DescriptionLevel >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFormat_IsEqualTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFormat *arg1 = 0 ;
  lldb::SBTypeFormat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeFormat_IsEqualTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFormat_IsEqualTo" "', argument " "1"" of type '" "lldb::SBTypeFormat *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFormat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeFormat,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeFormat_IsEqualTo" "', argument " "2"" of type '" "lldb::SBTypeFormat &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeFormat_IsEqualTo" "', argument " "2"" of type '" "lldb::SBTypeFormat &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeFormat * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsEqualTo(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeFormat___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFormat *arg1 = 0 ;
  lldb::SBTypeFormat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeFormat___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFormat___eq__" "', argument " "1"" of type '" "lldb::SBTypeFormat *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFormat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeFormat,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeFormat___eq__" "', argument " "2"" of type '" "lldb::SBTypeFormat &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeFormat___eq__" "', argument " "2"" of type '" "lldb::SBTypeFormat &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeFormat * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator ==(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBTypeFormat___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFormat *arg1 = 0 ;
  lldb::SBTypeFormat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeFormat___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFormat___ne__" "', argument " "1"" of type '" "lldb::SBTypeFormat *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFormat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeFormat,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeFormat___ne__" "', argument " "2"" of type '" "lldb::SBTypeFormat &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeFormat___ne__" "', argument " "2"" of type '" "lldb::SBTypeFormat &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeFormat * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator !=(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBTypeFormat___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeFormat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeFormat___repr__" "', argument " "1"" of type '" "lldb::SBTypeFormat *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeFormat * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBTypeFormat___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBTypeFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBTypeFormat, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBTypeFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBTypeNameSpecifier__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBTypeNameSpecifier *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeNameSpecifier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeNameSpecifier__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  bool arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  lldb::SBTypeNameSpecifier *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeNameSpecifier" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBTypeNameSpecifier" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier((char const *)arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeNameSpecifier, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeNameSpecifier__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  lldb::SBTypeNameSpecifier *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeNameSpecifier" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeNameSpecifier, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeNameSpecifier__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  lldb::FormatterMatchType arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  lldb::SBTypeNameSpecifier *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeNameSpecifier" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBTypeNameSpecifier" "', argument " "2"" of type '" "lldb::FormatterMatchType""'");
  } 
  arg2 = static_cast< lldb::FormatterMatchType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier((char const *)arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeNameSpecifier, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeNameSpecifier__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBType arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  lldb::SBTypeNameSpecifier *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeNameSpecifier" "', argument " "1"" of type '" "lldb::SBType""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBTypeNameSpecifier" "', argument " "1"" of type '" "lldb::SBType""'");
    } else {
      lldb::SBType * temp = reinterpret_cast< lldb::SBType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeNameSpecifier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeNameSpecifier__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTypeNameSpecifier *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBTypeNameSpecifier *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeNameSpecifier" "', argument " "1"" of type '" "lldb::SBTypeNameSpecifier const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBTypeNameSpecifier" "', argument " "1"" of type '" "lldb::SBTypeNameSpecifier const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier((lldb::SBTypeNameSpecifier const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeNameSpecifier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeNameSpecifier(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBTypeNameSpecifier", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBTypeNameSpecifier__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBType, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTypeNameSpecifier__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBTypeNameSpecifier, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTypeNameSpecifier__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTypeNameSpecifier__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SBTypeNameSpecifier__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SBTypeNameSpecifier__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBTypeNameSpecifier'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeNameSpecifier::SBTypeNameSpecifier()\n"
    "    lldb::SBTypeNameSpecifier::SBTypeNameSpecifier(char const *,bool)\n"
    "    lldb::SBTypeNameSpecifier::SBTypeNameSpecifier(char const *)\n"
    "    lldb::SBTypeNameSpecifier::SBTypeNameSpecifier(char const *,lldb::FormatterMatchType)\n"
    "    lldb::SBTypeNameSpecifier::SBTypeNameSpecifier(lldb::SBType)\n"
    "    lldb::SBTypeNameSpecifier::SBTypeNameSpecifier(lldb::SBTypeNameSpecifier const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBTypeNameSpecifier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeNameSpecifier *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeNameSpecifier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBTypeNameSpecifier" "', argument " "1"" of type '" "lldb::SBTypeNameSpecifier *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeNameSpecifier *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeNameSpecifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeNameSpecifier___nonzero__" "', argument " "1"" of type '" "lldb::SBTypeNameSpecifier const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeNameSpecifier const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeNameSpecifier *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeNameSpecifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeNameSpecifier_IsValid" "', argument " "1"" of type '" "lldb::SBTypeNameSpecifier const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeNameSpecifier const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeNameSpecifier *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeNameSpecifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeNameSpecifier_GetName" "', argument " "1"" of type '" "lldb::SBTypeNameSpecifier *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_GetType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeNameSpecifier *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeNameSpecifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeNameSpecifier_GetType" "', argument " "1"" of type '" "lldb::SBTypeNameSpecifier *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_GetMatchType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeNameSpecifier *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::FormatterMatchType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeNameSpecifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeNameSpecifier_GetMatchType" "', argument " "1"" of type '" "lldb::SBTypeNameSpecifier *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::FormatterMatchType)(arg1)->GetMatchType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_IsRegex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeNameSpecifier *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeNameSpecifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeNameSpecifier_IsRegex" "', argument " "1"" of type '" "lldb::SBTypeNameSpecifier *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsRegex();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeNameSpecifier *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::DescriptionLevel arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeNameSpecifier_GetDescription", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeNameSpecifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeNameSpecifier_GetDescription" "', argument " "1"" of type '" "lldb::SBTypeNameSpecifier *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeNameSpecifier_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeNameSpecifier_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTypeNameSpecifier_GetDescription" "', argument " "3"" of type '" "lldb::DescriptionLevel""'");
  } 
  arg3 = static_cast< lldb::DescriptionLevel >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier_IsEqualTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeNameSpecifier *arg1 = 0 ;
  lldb::SBTypeNameSpecifier *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeNameSpecifier_IsEqualTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeNameSpecifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeNameSpecifier_IsEqualTo" "', argument " "1"" of type '" "lldb::SBTypeNameSpecifier *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeNameSpecifier_IsEqualTo" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeNameSpecifier_IsEqualTo" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsEqualTo(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeNameSpecifier *arg1 = 0 ;
  lldb::SBTypeNameSpecifier *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeNameSpecifier___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeNameSpecifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeNameSpecifier___eq__" "', argument " "1"" of type '" "lldb::SBTypeNameSpecifier *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeNameSpecifier___eq__" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeNameSpecifier___eq__" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator ==(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeNameSpecifier *arg1 = 0 ;
  lldb::SBTypeNameSpecifier *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeNameSpecifier___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeNameSpecifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeNameSpecifier___ne__" "', argument " "1"" of type '" "lldb::SBTypeNameSpecifier *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeNameSpecifier,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeNameSpecifier___ne__" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeNameSpecifier___ne__" "', argument " "2"" of type '" "lldb::SBTypeNameSpecifier &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator !=(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBTypeNameSpecifier___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeNameSpecifier *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeNameSpecifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeNameSpecifier___repr__" "', argument " "1"" of type '" "lldb::SBTypeNameSpecifier *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeNameSpecifier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBTypeNameSpecifier___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBTypeNameSpecifier_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBTypeNameSpecifier, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBTypeNameSpecifier_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBTypeSummaryOptions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummaryOptions *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeSummaryOptions *)new lldb::SBTypeSummaryOptions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeSummaryOptions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeSummaryOptions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummaryOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBTypeSummaryOptions *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTypeSummaryOptions,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeSummaryOptions" "', argument " "1"" of type '" "lldb::SBTypeSummaryOptions const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBTypeSummaryOptions" "', argument " "1"" of type '" "lldb::SBTypeSummaryOptions const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummaryOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeSummaryOptions *)new lldb::SBTypeSummaryOptions((lldb::SBTypeSummaryOptions const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeSummaryOptions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeSummaryOptions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBTypeSummaryOptions", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBTypeSummaryOptions__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBTypeSummaryOptions, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTypeSummaryOptions__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBTypeSummaryOptions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeSummaryOptions::SBTypeSummaryOptions()\n"
    "    lldb::SBTypeSummaryOptions::SBTypeSummaryOptions(lldb::SBTypeSummaryOptions const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBTypeSummaryOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummaryOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummaryOptions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBTypeSummaryOptions" "', argument " "1"" of type '" "lldb::SBTypeSummaryOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummaryOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummaryOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummaryOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummaryOptions___nonzero__" "', argument " "1"" of type '" "lldb::SBTypeSummaryOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummaryOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeSummaryOptions const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummaryOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummaryOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummaryOptions_IsValid" "', argument " "1"" of type '" "lldb::SBTypeSummaryOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummaryOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions_GetLanguage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummaryOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::LanguageType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummaryOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummaryOptions_GetLanguage" "', argument " "1"" of type '" "lldb::SBTypeSummaryOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummaryOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::LanguageType)(arg1)->GetLanguage();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions_GetCapping(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummaryOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::TypeSummaryCapping result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummaryOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummaryOptions_GetCapping" "', argument " "1"" of type '" "lldb::SBTypeSummaryOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummaryOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::TypeSummaryCapping)(arg1)->GetCapping();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions_SetLanguage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummaryOptions *arg1 = 0 ;
  lldb::LanguageType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSummaryOptions_SetLanguage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummaryOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummaryOptions_SetLanguage" "', argument " "1"" of type '" "lldb::SBTypeSummaryOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummaryOptions * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeSummaryOptions_SetLanguage" "', argument " "2"" of type '" "lldb::LanguageType""'");
  } 
  arg2 = static_cast< lldb::LanguageType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetLanguage(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummaryOptions_SetCapping(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummaryOptions *arg1 = 0 ;
  lldb::TypeSummaryCapping arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSummaryOptions_SetCapping", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummaryOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummaryOptions_SetCapping" "', argument " "1"" of type '" "lldb::SBTypeSummaryOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummaryOptions * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeSummaryOptions_SetCapping" "', argument " "2"" of type '" "lldb::TypeSummaryCapping""'");
  } 
  arg2 = static_cast< lldb::TypeSummaryCapping >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetCapping(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBTypeSummaryOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBTypeSummaryOptions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBTypeSummaryOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBTypeSummary__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeSummary *)new lldb::SBTypeSummary();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeSummary, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithSummaryString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  uint32_t arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  lldb::SBTypeSummary result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_CreateWithSummaryString" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeSummary_CreateWithSummaryString" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBTypeSummary::CreateWithSummaryString((char const *)arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSummary(result)), SWIGTYPE_p_lldb__SBTypeSummary, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithSummaryString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  lldb::SBTypeSummary result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_CreateWithSummaryString" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBTypeSummary::CreateWithSummaryString((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSummary(result)), SWIGTYPE_p_lldb__SBTypeSummary, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithSummaryString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTypeSummary_CreateWithSummaryString", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBTypeSummary_CreateWithSummaryString__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBTypeSummary_CreateWithSummaryString__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTypeSummary_CreateWithSummaryString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeSummary::CreateWithSummaryString(char const *,uint32_t)\n"
    "    lldb::SBTypeSummary::CreateWithSummaryString(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithFunctionName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  uint32_t arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  lldb::SBTypeSummary result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_CreateWithFunctionName" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeSummary_CreateWithFunctionName" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBTypeSummary::CreateWithFunctionName((char const *)arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSummary(result)), SWIGTYPE_p_lldb__SBTypeSummary, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithFunctionName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  lldb::SBTypeSummary result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_CreateWithFunctionName" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBTypeSummary::CreateWithFunctionName((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSummary(result)), SWIGTYPE_p_lldb__SBTypeSummary, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithFunctionName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTypeSummary_CreateWithFunctionName", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBTypeSummary_CreateWithFunctionName__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBTypeSummary_CreateWithFunctionName__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTypeSummary_CreateWithFunctionName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeSummary::CreateWithFunctionName(char const *,uint32_t)\n"
    "    lldb::SBTypeSummary::CreateWithFunctionName(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithScriptCode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  uint32_t arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  lldb::SBTypeSummary result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_CreateWithScriptCode" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeSummary_CreateWithScriptCode" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBTypeSummary::CreateWithScriptCode((char const *)arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSummary(result)), SWIGTYPE_p_lldb__SBTypeSummary, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithScriptCode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  lldb::SBTypeSummary result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_CreateWithScriptCode" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBTypeSummary::CreateWithScriptCode((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSummary(result)), SWIGTYPE_p_lldb__SBTypeSummary, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_CreateWithScriptCode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTypeSummary_CreateWithScriptCode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBTypeSummary_CreateWithScriptCode__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBTypeSummary_CreateWithScriptCode__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTypeSummary_CreateWithScriptCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeSummary::CreateWithScriptCode(char const *,uint32_t)\n"
    "    lldb::SBTypeSummary::CreateWithScriptCode(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_SBTypeSummary__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBTypeSummary *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTypeSummary,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeSummary" "', argument " "1"" of type '" "lldb::SBTypeSummary const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBTypeSummary" "', argument " "1"" of type '" "lldb::SBTypeSummary const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeSummary *)new lldb::SBTypeSummary((lldb::SBTypeSummary const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeSummary, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeSummary(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBTypeSummary", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBTypeSummary__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBTypeSummary, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTypeSummary__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBTypeSummary'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeSummary::SBTypeSummary()\n"
    "    lldb::SBTypeSummary::SBTypeSummary(lldb::SBTypeSummary const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBTypeSummary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBTypeSummary" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary___nonzero__" "', argument " "1"" of type '" "lldb::SBTypeSummary const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeSummary const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_IsValid" "', argument " "1"" of type '" "lldb::SBTypeSummary const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeSummary const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_IsFunctionCode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_IsFunctionCode" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsFunctionCode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_IsFunctionName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_IsFunctionName" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsFunctionName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_IsSummaryString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_IsSummaryString" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsSummaryString();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_GetData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_GetData" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetData();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_SetSummaryString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSummary_SetSummaryString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_SetSummaryString" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeSummary_SetSummaryString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetSummaryString((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_SetFunctionName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSummary_SetFunctionName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_SetFunctionName" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeSummary_SetFunctionName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetFunctionName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_SetFunctionCode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSummary_SetFunctionCode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_SetFunctionCode" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeSummary_SetFunctionCode" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetFunctionCode((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_GetPtrMatchDepth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_GetPtrMatchDepth" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetPtrMatchDepth();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_SetPtrMatchDepth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSummary_SetPtrMatchDepth", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_SetPtrMatchDepth" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeSummary_SetPtrMatchDepth" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetPtrMatchDepth(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_GetOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_GetOptions" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetOptions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_SetOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSummary_SetOptions", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_SetOptions" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeSummary_SetOptions" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetOptions(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::DescriptionLevel arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSummary_GetDescription", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_GetDescription" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeSummary_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeSummary_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTypeSummary_GetDescription" "', argument " "3"" of type '" "lldb::DescriptionLevel""'");
  } 
  arg3 = static_cast< lldb::DescriptionLevel >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_DoesPrintValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  lldb::SBValue arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSummary_DoesPrintValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_DoesPrintValue" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBValue,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeSummary_DoesPrintValue" "', argument " "2"" of type '" "lldb::SBValue""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeSummary_DoesPrintValue" "', argument " "2"" of type '" "lldb::SBValue""'");
    } else {
      lldb::SBValue * temp = reinterpret_cast< lldb::SBValue * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->DoesPrintValue(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary_IsEqualTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  lldb::SBTypeSummary *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSummary_IsEqualTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary_IsEqualTo" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeSummary,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeSummary_IsEqualTo" "', argument " "2"" of type '" "lldb::SBTypeSummary &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeSummary_IsEqualTo" "', argument " "2"" of type '" "lldb::SBTypeSummary &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeSummary * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsEqualTo(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  lldb::SBTypeSummary *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSummary___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary___eq__" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeSummary,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeSummary___eq__" "', argument " "2"" of type '" "lldb::SBTypeSummary &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeSummary___eq__" "', argument " "2"" of type '" "lldb::SBTypeSummary &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeSummary * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator ==(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  lldb::SBTypeSummary *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSummary___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary___ne__" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeSummary,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeSummary___ne__" "', argument " "2"" of type '" "lldb::SBTypeSummary &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeSummary___ne__" "', argument " "2"" of type '" "lldb::SBTypeSummary &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeSummary * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator !=(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBTypeSummary___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSummary *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSummary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSummary___repr__" "', argument " "1"" of type '" "lldb::SBTypeSummary *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSummary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBTypeSummary___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBTypeSummary_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBTypeSummary, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBTypeSummary_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBTypeSynthetic__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeSynthetic *)new lldb::SBTypeSynthetic();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeSynthetic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic_CreateWithClassName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  uint32_t arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  lldb::SBTypeSynthetic result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic_CreateWithClassName" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeSynthetic_CreateWithClassName" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBTypeSynthetic::CreateWithClassName((char const *)arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSynthetic(result)), SWIGTYPE_p_lldb__SBTypeSynthetic, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic_CreateWithClassName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  lldb::SBTypeSynthetic result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic_CreateWithClassName" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBTypeSynthetic::CreateWithClassName((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSynthetic(result)), SWIGTYPE_p_lldb__SBTypeSynthetic, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic_CreateWithClassName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTypeSynthetic_CreateWithClassName", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBTypeSynthetic_CreateWithClassName__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBTypeSynthetic_CreateWithClassName__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTypeSynthetic_CreateWithClassName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeSynthetic::CreateWithClassName(char const *,uint32_t)\n"
    "    lldb::SBTypeSynthetic::CreateWithClassName(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic_CreateWithScriptCode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  uint32_t arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  lldb::SBTypeSynthetic result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic_CreateWithScriptCode" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeSynthetic_CreateWithScriptCode" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBTypeSynthetic::CreateWithScriptCode((char const *)arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSynthetic(result)), SWIGTYPE_p_lldb__SBTypeSynthetic, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic_CreateWithScriptCode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  lldb::SBTypeSynthetic result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic_CreateWithScriptCode" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBTypeSynthetic::CreateWithScriptCode((char const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSynthetic(result)), SWIGTYPE_p_lldb__SBTypeSynthetic, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic_CreateWithScriptCode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBTypeSynthetic_CreateWithScriptCode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBTypeSynthetic_CreateWithScriptCode__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBTypeSynthetic_CreateWithScriptCode__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBTypeSynthetic_CreateWithScriptCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeSynthetic::CreateWithScriptCode(char const *,uint32_t)\n"
    "    lldb::SBTypeSynthetic::CreateWithScriptCode(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_SBTypeSynthetic__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBTypeSynthetic *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBTypeSynthetic,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBTypeSynthetic" "', argument " "1"" of type '" "lldb::SBTypeSynthetic const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBTypeSynthetic" "', argument " "1"" of type '" "lldb::SBTypeSynthetic const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBTypeSynthetic *)new lldb::SBTypeSynthetic((lldb::SBTypeSynthetic const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBTypeSynthetic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBTypeSynthetic(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBTypeSynthetic", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBTypeSynthetic__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBTypeSynthetic, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBTypeSynthetic__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBTypeSynthetic'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBTypeSynthetic::SBTypeSynthetic()\n"
    "    lldb::SBTypeSynthetic::SBTypeSynthetic(lldb::SBTypeSynthetic const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBTypeSynthetic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSynthetic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBTypeSynthetic" "', argument " "1"" of type '" "lldb::SBTypeSynthetic *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSynthetic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic___nonzero__" "', argument " "1"" of type '" "lldb::SBTypeSynthetic const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeSynthetic const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSynthetic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic_IsValid" "', argument " "1"" of type '" "lldb::SBTypeSynthetic const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBTypeSynthetic const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic_IsClassCode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSynthetic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic_IsClassCode" "', argument " "1"" of type '" "lldb::SBTypeSynthetic *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsClassCode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic_IsClassName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSynthetic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic_IsClassName" "', argument " "1"" of type '" "lldb::SBTypeSynthetic *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsClassName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic_GetData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSynthetic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic_GetData" "', argument " "1"" of type '" "lldb::SBTypeSynthetic *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetData();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic_SetClassName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSynthetic_SetClassName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSynthetic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic_SetClassName" "', argument " "1"" of type '" "lldb::SBTypeSynthetic *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeSynthetic_SetClassName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetClassName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic_SetClassCode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSynthetic_SetClassCode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSynthetic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic_SetClassCode" "', argument " "1"" of type '" "lldb::SBTypeSynthetic *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeSynthetic_SetClassCode" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetClassCode((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic_GetOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSynthetic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic_GetOptions" "', argument " "1"" of type '" "lldb::SBTypeSynthetic *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetOptions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic_SetOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSynthetic_SetOptions", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSynthetic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic_SetOptions" "', argument " "1"" of type '" "lldb::SBTypeSynthetic *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBTypeSynthetic_SetOptions" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetOptions(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::DescriptionLevel arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSynthetic_GetDescription", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSynthetic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic_GetDescription" "', argument " "1"" of type '" "lldb::SBTypeSynthetic *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeSynthetic_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeSynthetic_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBTypeSynthetic_GetDescription" "', argument " "3"" of type '" "lldb::DescriptionLevel""'");
  } 
  arg3 = static_cast< lldb::DescriptionLevel >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic_IsEqualTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *arg1 = 0 ;
  lldb::SBTypeSynthetic *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSynthetic_IsEqualTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSynthetic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic_IsEqualTo" "', argument " "1"" of type '" "lldb::SBTypeSynthetic *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeSynthetic,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeSynthetic_IsEqualTo" "', argument " "2"" of type '" "lldb::SBTypeSynthetic &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeSynthetic_IsEqualTo" "', argument " "2"" of type '" "lldb::SBTypeSynthetic &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsEqualTo(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *arg1 = 0 ;
  lldb::SBTypeSynthetic *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSynthetic___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSynthetic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic___eq__" "', argument " "1"" of type '" "lldb::SBTypeSynthetic *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeSynthetic,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeSynthetic___eq__" "', argument " "2"" of type '" "lldb::SBTypeSynthetic &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeSynthetic___eq__" "', argument " "2"" of type '" "lldb::SBTypeSynthetic &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator ==(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *arg1 = 0 ;
  lldb::SBTypeSynthetic *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBTypeSynthetic___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSynthetic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic___ne__" "', argument " "1"" of type '" "lldb::SBTypeSynthetic *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTypeSynthetic,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBTypeSynthetic___ne__" "', argument " "2"" of type '" "lldb::SBTypeSynthetic &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBTypeSynthetic___ne__" "', argument " "2"" of type '" "lldb::SBTypeSynthetic &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->operator !=(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBTypeSynthetic___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBTypeSynthetic *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBTypeSynthetic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBTypeSynthetic___repr__" "', argument " "1"" of type '" "lldb::SBTypeSynthetic *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBTypeSynthetic * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBTypeSynthetic___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBTypeSynthetic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBTypeSynthetic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBTypeSynthetic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBUnixSignals__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBUnixSignals *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBUnixSignals *)new lldb::SBUnixSignals();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBUnixSignals, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBUnixSignals__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBUnixSignals *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBUnixSignals *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBUnixSignals,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBUnixSignals" "', argument " "1"" of type '" "lldb::SBUnixSignals const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBUnixSignals" "', argument " "1"" of type '" "lldb::SBUnixSignals const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBUnixSignals * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBUnixSignals *)new lldb::SBUnixSignals((lldb::SBUnixSignals const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBUnixSignals, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBUnixSignals(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBUnixSignals", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBUnixSignals__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBUnixSignals, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBUnixSignals__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBUnixSignals'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBUnixSignals::SBUnixSignals()\n"
    "    lldb::SBUnixSignals::SBUnixSignals(lldb::SBUnixSignals const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBUnixSignals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBUnixSignals *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBUnixSignals, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBUnixSignals" "', argument " "1"" of type '" "lldb::SBUnixSignals *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBUnixSignals * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBUnixSignals_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBUnixSignals *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBUnixSignals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBUnixSignals_Clear" "', argument " "1"" of type '" "lldb::SBUnixSignals *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBUnixSignals * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBUnixSignals___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBUnixSignals *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBUnixSignals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBUnixSignals___nonzero__" "', argument " "1"" of type '" "lldb::SBUnixSignals const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBUnixSignals * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBUnixSignals const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBUnixSignals_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBUnixSignals *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBUnixSignals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBUnixSignals_IsValid" "', argument " "1"" of type '" "lldb::SBUnixSignals const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBUnixSignals * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBUnixSignals const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBUnixSignals_GetSignalAsCString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBUnixSignals *arg1 = 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBUnixSignals_GetSignalAsCString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBUnixSignals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBUnixSignals_GetSignalAsCString" "', argument " "1"" of type '" "lldb::SBUnixSignals const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBUnixSignals * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBUnixSignals_GetSignalAsCString" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((lldb::SBUnixSignals const *)arg1)->GetSignalAsCString(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBUnixSignals_GetSignalNumberFromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBUnixSignals *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBUnixSignals_GetSignalNumberFromName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBUnixSignals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBUnixSignals_GetSignalNumberFromName" "', argument " "1"" of type '" "lldb::SBUnixSignals const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBUnixSignals * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBUnixSignals_GetSignalNumberFromName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int32_t)((lldb::SBUnixSignals const *)arg1)->GetSignalNumberFromName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBUnixSignals_GetShouldSuppress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBUnixSignals *arg1 = 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBUnixSignals_GetShouldSuppress", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBUnixSignals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBUnixSignals_GetShouldSuppress" "', argument " "1"" of type '" "lldb::SBUnixSignals const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBUnixSignals * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBUnixSignals_GetShouldSuppress" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBUnixSignals const *)arg1)->GetShouldSuppress(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBUnixSignals_SetShouldSuppress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBUnixSignals *arg1 = 0 ;
  int32_t arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBUnixSignals_SetShouldSuppress", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBUnixSignals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBUnixSignals_SetShouldSuppress" "', argument " "1"" of type '" "lldb::SBUnixSignals *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBUnixSignals * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBUnixSignals_SetShouldSuppress" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBUnixSignals_SetShouldSuppress" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetShouldSuppress(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBUnixSignals_GetShouldStop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBUnixSignals *arg1 = 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBUnixSignals_GetShouldStop", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBUnixSignals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBUnixSignals_GetShouldStop" "', argument " "1"" of type '" "lldb::SBUnixSignals const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBUnixSignals * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBUnixSignals_GetShouldStop" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBUnixSignals const *)arg1)->GetShouldStop(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBUnixSignals_SetShouldStop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBUnixSignals *arg1 = 0 ;
  int32_t arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBUnixSignals_SetShouldStop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBUnixSignals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBUnixSignals_SetShouldStop" "', argument " "1"" of type '" "lldb::SBUnixSignals *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBUnixSignals * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBUnixSignals_SetShouldStop" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBUnixSignals_SetShouldStop" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetShouldStop(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBUnixSignals_GetShouldNotify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBUnixSignals *arg1 = 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBUnixSignals_GetShouldNotify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBUnixSignals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBUnixSignals_GetShouldNotify" "', argument " "1"" of type '" "lldb::SBUnixSignals const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBUnixSignals * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBUnixSignals_GetShouldNotify" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBUnixSignals const *)arg1)->GetShouldNotify(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBUnixSignals_SetShouldNotify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBUnixSignals *arg1 = 0 ;
  int32_t arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBUnixSignals_SetShouldNotify", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBUnixSignals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBUnixSignals_SetShouldNotify" "', argument " "1"" of type '" "lldb::SBUnixSignals *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBUnixSignals * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBUnixSignals_SetShouldNotify" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBUnixSignals_SetShouldNotify" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetShouldNotify(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBUnixSignals_GetNumSignals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBUnixSignals *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBUnixSignals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBUnixSignals_GetNumSignals" "', argument " "1"" of type '" "lldb::SBUnixSignals const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBUnixSignals * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int32_t)((lldb::SBUnixSignals const *)arg1)->GetNumSignals();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBUnixSignals_GetSignalAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBUnixSignals *arg1 = 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBUnixSignals_GetSignalAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBUnixSignals, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBUnixSignals_GetSignalAtIndex" "', argument " "1"" of type '" "lldb::SBUnixSignals const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBUnixSignals * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBUnixSignals_GetSignalAtIndex" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int32_t)((lldb::SBUnixSignals const *)arg1)->GetSignalAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBUnixSignals_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBUnixSignals, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBUnixSignals_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBValue *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBValue *)new lldb::SBValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBValue *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBValue,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBValue" "', argument " "1"" of type '" "lldb::SBValue const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBValue" "', argument " "1"" of type '" "lldb::SBValue const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBValue *)new lldb::SBValue((lldb::SBValue const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBValue", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBValue__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBValue__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBValue::SBValue()\n"
    "    lldb::SBValue::SBValue(lldb::SBValue const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBValue" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue___nonzero__" "', argument " "1"" of type '" "lldb::SBValue const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBValue const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_IsValid" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_Clear" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBError result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetError" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::user_id_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetID" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::user_id_t)(arg1)->GetID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetName" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetTypeName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetTypeName" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetTypeName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetDisplayTypeName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetDisplayTypeName" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetDisplayTypeName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetByteSize" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetByteSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_IsInScope(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_IsInScope" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsInScope();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::Format result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetFormat" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::Format)(arg1)->GetFormat();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_SetFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  lldb::Format arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValue_SetFormat", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_SetFormat" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValue_SetFormat" "', argument " "2"" of type '" "lldb::Format""'");
  } 
  arg2 = static_cast< lldb::Format >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetFormat(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetValue" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetValueAsSigned__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  int64_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long long val3 ;
  int ecode3 = 0 ;
  int64_t result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetValueAsSigned" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_GetValueAsSigned" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_GetValueAsSigned" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  ecode3 = SWIG_AsVal_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBValue_GetValueAsSigned" "', argument " "3"" of type '" "int64_t""'");
  } 
  arg3 = static_cast< int64_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int64_t)(arg1)->GetValueAsSigned(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetValueAsSigned__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int64_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetValueAsSigned" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_GetValueAsSigned" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_GetValueAsSigned" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int64_t)(arg1)->GetValueAsSigned(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetValueAsUnsigned__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  uint64_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  uint64_t result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetValueAsUnsigned" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_GetValueAsUnsigned" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_GetValueAsUnsigned" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBValue_GetValueAsUnsigned" "', argument " "3"" of type '" "uint64_t""'");
  } 
  arg3 = static_cast< uint64_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetValueAsUnsigned(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetValueAsUnsigned__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  lldb::SBError *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  uint64_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetValueAsUnsigned" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_GetValueAsUnsigned" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_GetValueAsUnsigned" "', argument " "2"" of type '" "lldb::SBError &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBError * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetValueAsUnsigned(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetValueAsSigned__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  int64_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetValueAsSigned" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValue_GetValueAsSigned" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = static_cast< int64_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int64_t)(arg1)->GetValueAsSigned(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetValueAsSigned__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int64_t result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetValueAsSigned" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int64_t)(arg1)->GetValueAsSigned();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetValueAsSigned(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBValue_GetValueAsSigned", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBValue_GetValueAsSigned__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBValue_GetValueAsSigned__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBValue_GetValueAsSigned__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBValue_GetValueAsSigned__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBValue_GetValueAsSigned'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBValue::GetValueAsSigned(lldb::SBError &,int64_t)\n"
    "    lldb::SBValue::GetValueAsSigned(lldb::SBError &)\n"
    "    lldb::SBValue::GetValueAsSigned(int64_t)\n"
    "    lldb::SBValue::GetValueAsSigned()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBValue_GetValueAsUnsigned__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  uint64_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetValueAsUnsigned" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValue_GetValueAsUnsigned" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetValueAsUnsigned(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetValueAsUnsigned__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint64_t result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetValueAsUnsigned" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint64_t)(arg1)->GetValueAsUnsigned();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetValueAsUnsigned(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBValue_GetValueAsUnsigned", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBValue_GetValueAsUnsigned__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBValue_GetValueAsUnsigned__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBValue_GetValueAsUnsigned__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBValue_GetValueAsUnsigned__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBValue_GetValueAsUnsigned'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBValue::GetValueAsUnsigned(lldb::SBError &,uint64_t)\n"
    "    lldb::SBValue::GetValueAsUnsigned(lldb::SBError &)\n"
    "    lldb::SBValue::GetValueAsUnsigned(uint64_t)\n"
    "    lldb::SBValue::GetValueAsUnsigned()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBValue_GetValueAsAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetValueAsAddress" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->GetValueAsAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetValueType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::ValueType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetValueType" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::ValueType)(arg1)->GetValueType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetValueDidChange(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetValueDidChange" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetValueDidChange();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetSummary__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetSummary" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetSummary();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetSummary__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::SBTypeSummaryOptions *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetSummary" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_GetSummary" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_GetSummary" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBTypeSummaryOptions,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBValue_GetSummary" "', argument " "3"" of type '" "lldb::SBTypeSummaryOptions &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_GetSummary" "', argument " "3"" of type '" "lldb::SBTypeSummaryOptions &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBTypeSummaryOptions * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetSummary(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetSummary(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBValue_GetSummary", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBValue_GetSummary__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBTypeSummaryOptions, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBValue_GetSummary__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBValue_GetSummary'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBValue::GetSummary()\n"
    "    lldb::SBValue::GetSummary(lldb::SBStream &,lldb::SBTypeSummaryOptions &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBValue_GetObjectDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetObjectDescription" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetObjectDescription();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetDynamicValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  lldb::DynamicValueType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValue_GetDynamicValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetDynamicValue" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValue_GetDynamicValue" "', argument " "2"" of type '" "lldb::DynamicValueType""'");
  } 
  arg2 = static_cast< lldb::DynamicValueType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetDynamicValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetStaticValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBValue result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetStaticValue" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetStaticValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetNonSyntheticValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBValue result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetNonSyntheticValue" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetNonSyntheticValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetSyntheticValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBValue result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetSyntheticValue" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetSyntheticValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetPreferDynamicValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::DynamicValueType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetPreferDynamicValue" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::DynamicValueType)(arg1)->GetPreferDynamicValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_SetPreferDynamicValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  lldb::DynamicValueType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValue_SetPreferDynamicValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_SetPreferDynamicValue" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValue_SetPreferDynamicValue" "', argument " "2"" of type '" "lldb::DynamicValueType""'");
  } 
  arg2 = static_cast< lldb::DynamicValueType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetPreferDynamicValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetPreferSyntheticValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetPreferSyntheticValue" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetPreferSyntheticValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_SetPreferSyntheticValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValue_SetPreferSyntheticValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_SetPreferSyntheticValue" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValue_SetPreferSyntheticValue" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetPreferSyntheticValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_IsDynamic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_IsDynamic" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsDynamic();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_IsSynthetic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_IsSynthetic" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsSynthetic();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_IsSyntheticChildrenGenerated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_IsSyntheticChildrenGenerated" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsSyntheticChildrenGenerated();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_SetSyntheticChildrenGenerated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValue_SetSyntheticChildrenGenerated", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_SetSyntheticChildrenGenerated" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValue_SetSyntheticChildrenGenerated" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetSyntheticChildrenGenerated(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetLocation" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetLocation();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_SetValueFromCString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_SetValueFromCString" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_SetValueFromCString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetValueFromCString((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_SetValueFromCString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBError *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_SetValueFromCString" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_SetValueFromCString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBValue_SetValueFromCString" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_SetValueFromCString" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBError * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetValueFromCString((char const *)arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_SetValueFromCString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBValue_SetValueFromCString", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBValue_SetValueFromCString__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBValue_SetValueFromCString__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBValue_SetValueFromCString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBValue::SetValueFromCString(char const *)\n"
    "    lldb::SBValue::SetValueFromCString(char const *,lldb::SBError &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBValue_GetTypeFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTypeFormat result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetTypeFormat" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTypeFormat();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeFormat(result)), SWIGTYPE_p_lldb__SBTypeFormat, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetTypeSummary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTypeSummary result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetTypeSummary" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTypeSummary();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSummary(result)), SWIGTYPE_p_lldb__SBTypeSummary, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetTypeFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTypeFilter result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetTypeFilter" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTypeFilter();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeFilter(result)), SWIGTYPE_p_lldb__SBTypeFilter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetTypeSynthetic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTypeSynthetic result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetTypeSynthetic" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTypeSynthetic();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTypeSynthetic(result)), SWIGTYPE_p_lldb__SBTypeSynthetic, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetChildAtIndex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetChildAtIndex" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValue_GetChildAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetChildAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_CreateChildAtOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  char *arg2 = 0 ;
  uint32_t arg3 ;
  lldb::SBType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValue_CreateChildAtOffset", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_CreateChildAtOffset" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_CreateChildAtOffset" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBValue_CreateChildAtOffset" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBType,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBValue_CreateChildAtOffset" "', argument " "4"" of type '" "lldb::SBType""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_CreateChildAtOffset" "', argument " "4"" of type '" "lldb::SBType""'");
    } else {
      lldb::SBType * temp = reinterpret_cast< lldb::SBType * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateChildAtOffset((char const *)arg2,arg3,SWIG_STD_MOVE(arg4));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_Cast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  lldb::SBType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValue_Cast", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_Cast" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_Cast" "', argument " "2"" of type '" "lldb::SBType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_Cast" "', argument " "2"" of type '" "lldb::SBType""'");
    } else {
      lldb::SBType * temp = reinterpret_cast< lldb::SBType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Cast(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_CreateValueFromExpression__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_CreateValueFromExpression" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_CreateValueFromExpression" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBValue_CreateValueFromExpression" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateValueFromExpression((char const *)arg2,(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_CreateValueFromExpression__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  lldb::SBExpressionOptions *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_CreateValueFromExpression" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_CreateValueFromExpression" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBValue_CreateValueFromExpression" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBExpressionOptions,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBValue_CreateValueFromExpression" "', argument " "4"" of type '" "lldb::SBExpressionOptions &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_CreateValueFromExpression" "', argument " "4"" of type '" "lldb::SBExpressionOptions &""'"); 
  }
  arg4 = reinterpret_cast< lldb::SBExpressionOptions * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateValueFromExpression((char const *)arg2,(char const *)arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_CreateValueFromExpression(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBValue_CreateValueFromExpression", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBValue_CreateValueFromExpression__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBValue_CreateValueFromExpression__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBValue_CreateValueFromExpression'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBValue::CreateValueFromExpression(char const *,char const *)\n"
    "    lldb::SBValue::CreateValueFromExpression(char const *,char const *,lldb::SBExpressionOptions &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBValue_CreateValueFromAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::addr_t arg3 ;
  lldb::SBType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValue_CreateValueFromAddress", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_CreateValueFromAddress" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_CreateValueFromAddress" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBValue_CreateValueFromAddress" "', argument " "3"" of type '" "lldb::addr_t""'");
  } 
  arg3 = static_cast< lldb::addr_t >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBType,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBValue_CreateValueFromAddress" "', argument " "4"" of type '" "lldb::SBType""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_CreateValueFromAddress" "', argument " "4"" of type '" "lldb::SBType""'");
    } else {
      lldb::SBType * temp = reinterpret_cast< lldb::SBType * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateValueFromAddress((char const *)arg2,arg3,SWIG_STD_MOVE(arg4));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_CreateValueFromData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBData arg3 ;
  lldb::SBType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValue_CreateValueFromData", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_CreateValueFromData" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_CreateValueFromData" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBData,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBValue_CreateValueFromData" "', argument " "3"" of type '" "lldb::SBData""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_CreateValueFromData" "', argument " "3"" of type '" "lldb::SBData""'");
    } else {
      lldb::SBData * temp = reinterpret_cast< lldb::SBData * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_lldb__SBType,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBValue_CreateValueFromData" "', argument " "4"" of type '" "lldb::SBType""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_CreateValueFromData" "', argument " "4"" of type '" "lldb::SBType""'");
    } else {
      lldb::SBType * temp = reinterpret_cast< lldb::SBType * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateValueFromData((char const *)arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_CreateBoolValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  char *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValue_CreateBoolValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_CreateBoolValue" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_CreateBoolValue" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBValue_CreateBoolValue" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->CreateBoolValue((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetChildAtIndex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  uint32_t arg2 ;
  lldb::DynamicValueType arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetChildAtIndex" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValue_GetChildAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBValue_GetChildAtIndex" "', argument " "3"" of type '" "lldb::DynamicValueType""'");
  } 
  arg3 = static_cast< lldb::DynamicValueType >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBValue_GetChildAtIndex" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetChildAtIndex(arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetChildAtIndex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBValue_GetChildAtIndex", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBValue_GetChildAtIndex__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBValue_GetChildAtIndex__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBValue_GetChildAtIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBValue::GetChildAtIndex(uint32_t)\n"
    "    lldb::SBValue::GetChildAtIndex(uint32_t,lldb::DynamicValueType,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBValue_GetIndexOfChildWithName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValue_GetIndexOfChildWithName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetIndexOfChildWithName" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_GetIndexOfChildWithName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetIndexOfChildWithName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetChildMemberWithName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetChildMemberWithName" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_GetChildMemberWithName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetChildMemberWithName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetChildMemberWithName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::DynamicValueType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetChildMemberWithName" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_GetChildMemberWithName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBValue_GetChildMemberWithName" "', argument " "3"" of type '" "lldb::DynamicValueType""'");
  } 
  arg3 = static_cast< lldb::DynamicValueType >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetChildMemberWithName((char const *)arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetChildMemberWithName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBValue_GetChildMemberWithName", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBValue_GetChildMemberWithName__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBValue_GetChildMemberWithName__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBValue_GetChildMemberWithName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBValue::GetChildMemberWithName(char const *)\n"
    "    lldb::SBValue::GetChildMemberWithName(char const *,lldb::DynamicValueType)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBValue_GetValueForExpressionPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValue_GetValueForExpressionPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetValueForExpressionPath" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_GetValueForExpressionPath" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetValueForExpressionPath((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_AddressOf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBValue result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_AddressOf" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->AddressOf();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetLoadAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetLoadAddress" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->GetLoadAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBAddress result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetAddress" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBAddress(result)), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetPointeeData__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  lldb::SBData result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetPointeeData" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValue_GetPointeeData" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBValue_GetPointeeData" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetPointeeData(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBData(result)), SWIGTYPE_p_lldb__SBData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetPointeeData__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  lldb::SBData result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetPointeeData" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValue_GetPointeeData" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetPointeeData(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBData(result)), SWIGTYPE_p_lldb__SBData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetPointeeData__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBData result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetPointeeData" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetPointeeData();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBData(result)), SWIGTYPE_p_lldb__SBData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetPointeeData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBValue_GetPointeeData", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBValue_GetPointeeData__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBValue_GetPointeeData__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBValue_GetPointeeData__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBValue_GetPointeeData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBValue::GetPointeeData(uint32_t,uint32_t)\n"
    "    lldb::SBValue::GetPointeeData(uint32_t)\n"
    "    lldb::SBValue::GetPointeeData()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBValue_GetData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBData result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetData" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetData();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBData(result)), SWIGTYPE_p_lldb__SBData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_SetData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  lldb::SBData *arg2 = 0 ;
  lldb::SBError *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValue_SetData", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_SetData" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBData,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_SetData" "', argument " "2"" of type '" "lldb::SBData &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_SetData" "', argument " "2"" of type '" "lldb::SBData &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBData * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBValue_SetData" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_SetData" "', argument " "3"" of type '" "lldb::SBError &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBError * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->SetData(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_Clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValue_Clone", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_Clone" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_Clone" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Clone((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetDeclaration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBDeclaration result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetDeclaration" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetDeclaration();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBDeclaration(result)), SWIGTYPE_p_lldb__SBDeclaration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_MightHaveChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_MightHaveChildren" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->MightHaveChildren();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_IsRuntimeSupportValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_IsRuntimeSupportValue" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsRuntimeSupportValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetNumChildren__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint32_t result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetNumChildren" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumChildren();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetNumChildren__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  uint32_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetNumChildren" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValue_GetNumChildren" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetNumChildren(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetNumChildren(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBValue_GetNumChildren", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBValue_GetNumChildren__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBValue_GetNumChildren__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBValue_GetNumChildren'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBValue::GetNumChildren()\n"
    "    lldb::SBValue::GetNumChildren(uint32_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBValue_GetOpaqueType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetOpaqueType" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (void *)(arg1)->GetOpaqueType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBTarget result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetTarget" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetTarget();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBTarget(result)), SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBProcess result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetProcess" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetProcess();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBProcess(result)), SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBThread result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetThread" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetThread();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBThread(result)), SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetFrame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBFrame result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetFrame" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetFrame();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBFrame(result)), SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_Dereference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBValue result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_Dereference" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Dereference();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_TypeIsPointerType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_TypeIsPointerType" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->TypeIsPointerType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetType" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_Persist(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBValue result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_Persist" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Persist();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetDescription__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetDescription" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetDescription__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::DescriptionLevel arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetDescription" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBValue_GetDescription" "', argument " "3"" of type '" "lldb::DescriptionLevel""'");
  } 
  arg3 = static_cast< lldb::DescriptionLevel >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBValue_GetDescription", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBValue_GetDescription__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBValue_GetDescription__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBValue_GetDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBValue::GetDescription(lldb::SBStream &)\n"
    "    lldb::SBValue::GetDescription(lldb::SBStream &,lldb::DescriptionLevel)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBValue_GetExpressionPath__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetExpressionPath" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_GetExpressionPath" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_GetExpressionPath" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetExpressionPath(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetExpressionPath__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetExpressionPath" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_GetExpressionPath" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_GetExpressionPath" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBValue_GetExpressionPath" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetExpressionPath(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetExpressionPath(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBValue_GetExpressionPath", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBValue_GetExpressionPath__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBValue_GetExpressionPath__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBValue_GetExpressionPath'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBValue::GetExpressionPath(lldb::SBStream &)\n"
    "    lldb::SBValue::GetExpressionPath(lldb::SBStream &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBValue_EvaluateExpression__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_EvaluateExpression" "', argument " "1"" of type '" "lldb::SBValue const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_EvaluateExpression" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBValue const *)arg1)->EvaluateExpression((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_EvaluateExpression__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBExpressionOptions *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_EvaluateExpression" "', argument " "1"" of type '" "lldb::SBValue const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_EvaluateExpression" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBExpressionOptions,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBValue_EvaluateExpression" "', argument " "3"" of type '" "lldb::SBExpressionOptions const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_EvaluateExpression" "', argument " "3"" of type '" "lldb::SBExpressionOptions const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBExpressionOptions * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBValue const *)arg1)->EvaluateExpression((char const *)arg2,(lldb::SBExpressionOptions const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_EvaluateExpression__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  char *arg2 = 0 ;
  lldb::SBExpressionOptions *arg3 = 0 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  lldb::SBValue result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_EvaluateExpression" "', argument " "1"" of type '" "lldb::SBValue const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValue_EvaluateExpression" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_lldb__SBExpressionOptions,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBValue_EvaluateExpression" "', argument " "3"" of type '" "lldb::SBExpressionOptions const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_EvaluateExpression" "', argument " "3"" of type '" "lldb::SBExpressionOptions const &""'"); 
  }
  arg3 = reinterpret_cast< lldb::SBExpressionOptions * >(argp3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBValue_EvaluateExpression" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBValue const *)arg1)->EvaluateExpression((char const *)arg2,(lldb::SBExpressionOptions const &)*arg3,(char const *)arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_EvaluateExpression(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBValue_EvaluateExpression", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBValue_EvaluateExpression__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBValue_EvaluateExpression__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBValue_EvaluateExpression__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBValue_EvaluateExpression'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBValue::EvaluateExpression(char const *) const\n"
    "    lldb::SBValue::EvaluateExpression(char const *,lldb::SBExpressionOptions const &) const\n"
    "    lldb::SBValue::EvaluateExpression(char const *,lldb::SBExpressionOptions const &,char const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBValue_Watch__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  lldb::SBError *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  lldb::SBWatchpoint result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_Watch" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValue_Watch" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBValue_Watch" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBValue_Watch" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBValue_Watch" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_Watch" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBError * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Watch(arg2,arg3,arg4,*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBWatchpoint(result)), SWIGTYPE_p_lldb__SBWatchpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_Watch__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  lldb::SBWatchpoint result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_Watch" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValue_Watch" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBValue_Watch" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBValue_Watch" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->Watch(arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBWatchpoint(result)), SWIGTYPE_p_lldb__SBWatchpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_Watch(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBValue_Watch", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBValue_Watch__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SBValue_Watch__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBValue_Watch'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBValue::Watch(bool,bool,bool,lldb::SBError &)\n"
    "    lldb::SBValue::Watch(bool,bool,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBValue_WatchPointee(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  lldb::SBError *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  lldb::SBWatchpoint result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValue_WatchPointee", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_WatchPointee" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValue_WatchPointee" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBValue_WatchPointee" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBValue_WatchPointee" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_lldb__SBError,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SBValue_WatchPointee" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValue_WatchPointee" "', argument " "5"" of type '" "lldb::SBError &""'"); 
  }
  arg5 = reinterpret_cast< lldb::SBError * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->WatchPointee(arg2,arg3,arg4,*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBWatchpoint(result)), SWIGTYPE_p_lldb__SBWatchpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue_GetVTable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBValue result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue_GetVTable" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetVTable();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValue___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValue___repr__" "', argument " "1"" of type '" "lldb::SBValue *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBValue___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBValueList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBValueList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBValueList *)new lldb::SBValueList();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBValueList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValueList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBValueList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBValueList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBValueList" "', argument " "1"" of type '" "lldb::SBValueList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBValueList" "', argument " "1"" of type '" "lldb::SBValueList const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValueList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBValueList *)new lldb::SBValueList((lldb::SBValueList const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBValueList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBValueList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBValueList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBValueList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBValueList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBValueList::SBValueList()\n"
    "    lldb::SBValueList::SBValueList(lldb::SBValueList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBValueList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValueList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBValueList" "', argument " "1"" of type '" "lldb::SBValueList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValueList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValueList___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValueList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValueList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValueList___nonzero__" "', argument " "1"" of type '" "lldb::SBValueList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValueList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBValueList const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValueList_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValueList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValueList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValueList_IsValid" "', argument " "1"" of type '" "lldb::SBValueList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValueList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBValueList const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValueList_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValueList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValueList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValueList_Clear" "', argument " "1"" of type '" "lldb::SBValueList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValueList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValueList_Append__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValueList *arg1 = 0 ;
  lldb::SBValue *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValueList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValueList_Append" "', argument " "1"" of type '" "lldb::SBValueList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValueList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBValue,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValueList_Append" "', argument " "2"" of type '" "lldb::SBValue const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValueList_Append" "', argument " "2"" of type '" "lldb::SBValue const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBValue * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Append((lldb::SBValue const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValueList_Append__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBValueList *arg1 = 0 ;
  lldb::SBValueList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValueList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValueList_Append" "', argument " "1"" of type '" "lldb::SBValueList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValueList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBValueList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValueList_Append" "', argument " "2"" of type '" "lldb::SBValueList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBValueList_Append" "', argument " "2"" of type '" "lldb::SBValueList const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBValueList * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Append((lldb::SBValueList const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValueList_Append(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBValueList_Append", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValueList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBValueList_Append__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBValueList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBValueList_Append__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBValueList_Append'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBValueList::Append(lldb::SBValue const &)\n"
    "    lldb::SBValueList::Append(lldb::SBValueList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBValueList_GetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValueList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValueList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValueList_GetSize" "', argument " "1"" of type '" "lldb::SBValueList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValueList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)((lldb::SBValueList const *)arg1)->GetSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValueList_GetValueAtIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValueList *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValueList_GetValueAtIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValueList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValueList_GetValueAtIndex" "', argument " "1"" of type '" "lldb::SBValueList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValueList * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValueList_GetValueAtIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBValueList const *)arg1)->GetValueAtIndex(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValueList_GetFirstValueByName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValueList *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValueList_GetFirstValueByName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValueList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValueList_GetFirstValueByName" "', argument " "1"" of type '" "lldb::SBValueList const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValueList * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBValueList_GetFirstValueByName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((lldb::SBValueList const *)arg1)->GetFirstValueByName((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValueList_FindValueObjectByUID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValueList *arg1 = 0 ;
  lldb::user_id_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  lldb::SBValue result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBValueList_FindValueObjectByUID", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValueList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValueList_FindValueObjectByUID" "', argument " "1"" of type '" "lldb::SBValueList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValueList * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBValueList_FindValueObjectByUID" "', argument " "2"" of type '" "lldb::user_id_t""'");
  } 
  arg2 = static_cast< lldb::user_id_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->FindValueObjectByUID(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBValue(result)), SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValueList_GetError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValueList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBError result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValueList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValueList_GetError" "', argument " "1"" of type '" "lldb::SBValueList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValueList * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBValueList___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBValueList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBValueList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBValueList___str__" "', argument " "1"" of type '" "lldb::SBValueList *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBValueList * >(argp1);
  result = lldb_SBValueList___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBValueList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBValueList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBValueList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBVariablesOptions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBVariablesOptions *)new lldb::SBVariablesOptions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBVariablesOptions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBVariablesOptions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBVariablesOptions *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBVariablesOptions,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBVariablesOptions" "', argument " "1"" of type '" "lldb::SBVariablesOptions const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBVariablesOptions" "', argument " "1"" of type '" "lldb::SBVariablesOptions const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBVariablesOptions *)new lldb::SBVariablesOptions((lldb::SBVariablesOptions const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBVariablesOptions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBVariablesOptions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBVariablesOptions", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBVariablesOptions__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBVariablesOptions, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBVariablesOptions__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBVariablesOptions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBVariablesOptions::SBVariablesOptions()\n"
    "    lldb::SBVariablesOptions::SBVariablesOptions(lldb::SBVariablesOptions const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBVariablesOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBVariablesOptions" "', argument " "1"" of type '" "lldb::SBVariablesOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBVariablesOptions___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBVariablesOptions___nonzero__" "', argument " "1"" of type '" "lldb::SBVariablesOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBVariablesOptions const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBVariablesOptions_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBVariablesOptions_IsValid" "', argument " "1"" of type '" "lldb::SBVariablesOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBVariablesOptions const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetIncludeArguments(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBVariablesOptions_GetIncludeArguments" "', argument " "1"" of type '" "lldb::SBVariablesOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetIncludeArguments();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetIncludeArguments(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBVariablesOptions_SetIncludeArguments", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBVariablesOptions_SetIncludeArguments" "', argument " "1"" of type '" "lldb::SBVariablesOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBVariablesOptions_SetIncludeArguments" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetIncludeArguments(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetIncludeRecognizedArguments(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  lldb::SBTarget *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBVariablesOptions_GetIncludeRecognizedArguments", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBVariablesOptions_GetIncludeRecognizedArguments" "', argument " "1"" of type '" "lldb::SBVariablesOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBVariablesOptions_GetIncludeRecognizedArguments" "', argument " "2"" of type '" "lldb::SBTarget const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBVariablesOptions_GetIncludeRecognizedArguments" "', argument " "2"" of type '" "lldb::SBTarget const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetIncludeRecognizedArguments((lldb::SBTarget const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetIncludeRecognizedArguments(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBVariablesOptions_SetIncludeRecognizedArguments", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBVariablesOptions_SetIncludeRecognizedArguments" "', argument " "1"" of type '" "lldb::SBVariablesOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBVariablesOptions_SetIncludeRecognizedArguments" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetIncludeRecognizedArguments(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetIncludeLocals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBVariablesOptions_GetIncludeLocals" "', argument " "1"" of type '" "lldb::SBVariablesOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetIncludeLocals();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetIncludeLocals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBVariablesOptions_SetIncludeLocals", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBVariablesOptions_SetIncludeLocals" "', argument " "1"" of type '" "lldb::SBVariablesOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBVariablesOptions_SetIncludeLocals" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetIncludeLocals(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetIncludeStatics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBVariablesOptions_GetIncludeStatics" "', argument " "1"" of type '" "lldb::SBVariablesOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetIncludeStatics();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetIncludeStatics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBVariablesOptions_SetIncludeStatics", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBVariablesOptions_SetIncludeStatics" "', argument " "1"" of type '" "lldb::SBVariablesOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBVariablesOptions_SetIncludeStatics" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetIncludeStatics(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetInScopeOnly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBVariablesOptions_GetInScopeOnly" "', argument " "1"" of type '" "lldb::SBVariablesOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetInScopeOnly();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetInScopeOnly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBVariablesOptions_SetInScopeOnly", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBVariablesOptions_SetInScopeOnly" "', argument " "1"" of type '" "lldb::SBVariablesOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBVariablesOptions_SetInScopeOnly" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetInScopeOnly(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetIncludeRuntimeSupportValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBVariablesOptions_GetIncludeRuntimeSupportValues" "', argument " "1"" of type '" "lldb::SBVariablesOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetIncludeRuntimeSupportValues();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetIncludeRuntimeSupportValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBVariablesOptions_SetIncludeRuntimeSupportValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBVariablesOptions_SetIncludeRuntimeSupportValues" "', argument " "1"" of type '" "lldb::SBVariablesOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBVariablesOptions_SetIncludeRuntimeSupportValues" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetIncludeRuntimeSupportValues(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBVariablesOptions_GetUseDynamic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::DynamicValueType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBVariablesOptions_GetUseDynamic" "', argument " "1"" of type '" "lldb::SBVariablesOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::DynamicValueType)((lldb::SBVariablesOptions const *)arg1)->GetUseDynamic();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBVariablesOptions_SetUseDynamic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBVariablesOptions *arg1 = 0 ;
  lldb::DynamicValueType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBVariablesOptions_SetUseDynamic", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBVariablesOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBVariablesOptions_SetUseDynamic" "', argument " "1"" of type '" "lldb::SBVariablesOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBVariablesOptions * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBVariablesOptions_SetUseDynamic" "', argument " "2"" of type '" "lldb::DynamicValueType""'");
  } 
  arg2 = static_cast< lldb::DynamicValueType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetUseDynamic(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBVariablesOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBVariablesOptions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBVariablesOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBWatchpoint__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBWatchpoint *)new lldb::SBWatchpoint();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBWatchpoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBWatchpoint__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBWatchpoint *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBWatchpoint,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBWatchpoint" "', argument " "1"" of type '" "lldb::SBWatchpoint const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBWatchpoint" "', argument " "1"" of type '" "lldb::SBWatchpoint const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBWatchpoint *)new lldb::SBWatchpoint((lldb::SBWatchpoint const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBWatchpoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBWatchpoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBWatchpoint", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBWatchpoint__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBWatchpoint, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBWatchpoint__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBWatchpoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBWatchpoint::SBWatchpoint()\n"
    "    lldb::SBWatchpoint::SBWatchpoint(lldb::SBWatchpoint const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBWatchpoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBWatchpoint" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint___nonzero__" "', argument " "1"" of type '" "lldb::SBWatchpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBWatchpoint const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  lldb::SBWatchpoint *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBWatchpoint___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint___eq__" "', argument " "1"" of type '" "lldb::SBWatchpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBWatchpoint,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBWatchpoint___eq__" "', argument " "2"" of type '" "lldb::SBWatchpoint const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBWatchpoint___eq__" "', argument " "2"" of type '" "lldb::SBWatchpoint const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBWatchpoint * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBWatchpoint const *)arg1)->operator ==((lldb::SBWatchpoint const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  lldb::SBWatchpoint *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBWatchpoint___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint___ne__" "', argument " "1"" of type '" "lldb::SBWatchpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBWatchpoint,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBWatchpoint___ne__" "', argument " "2"" of type '" "lldb::SBWatchpoint const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBWatchpoint___ne__" "', argument " "2"" of type '" "lldb::SBWatchpoint const &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBWatchpoint * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBWatchpoint const *)arg1)->operator !=((lldb::SBWatchpoint const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_IsValid" "', argument " "1"" of type '" "lldb::SBWatchpoint const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBWatchpoint const *)arg1)->IsValid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_GetError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBError result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_GetError" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBError(result)), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_GetID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::watch_id_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_GetID" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::watch_id_t)(arg1)->GetID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_GetHardwareIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_GetHardwareIndex" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int32_t)(arg1)->GetHardwareIndex();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_GetWatchAddress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::addr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_GetWatchAddress" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::addr_t)(arg1)->GetWatchAddress();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_GetWatchSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_GetWatchSize" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetWatchSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_SetEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBWatchpoint_SetEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_SetEnabled" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBWatchpoint_SetEnabled" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetEnabled(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_IsEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_IsEnabled" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsEnabled();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_GetHitCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_GetHitCount" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetHitCount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_GetIgnoreCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_GetIgnoreCount" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (uint32_t)(arg1)->GetIgnoreCount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_SetIgnoreCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBWatchpoint_SetIgnoreCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_SetIgnoreCount" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBWatchpoint_SetIgnoreCount" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetIgnoreCount(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_GetCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_GetCondition" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetCondition();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_SetCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBWatchpoint_SetCondition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_SetCondition" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBWatchpoint_SetCondition" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetCondition((char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_GetDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  lldb::SBStream *arg2 = 0 ;
  lldb::DescriptionLevel arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBWatchpoint_GetDescription", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_GetDescription" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBWatchpoint_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBWatchpoint_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
  }
  arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBWatchpoint_GetDescription" "', argument " "3"" of type '" "lldb::DescriptionLevel""'");
  } 
  arg3 = static_cast< lldb::DescriptionLevel >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->GetDescription(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_Clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_Clear" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->Clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_EventIsWatchpointEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_EventIsWatchpointEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBWatchpoint_EventIsWatchpointEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)lldb::SBWatchpoint::EventIsWatchpointEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_GetWatchpointEventTypeFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::WatchpointEventType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_GetWatchpointEventTypeFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBWatchpoint_GetWatchpointEventTypeFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::WatchpointEventType)lldb::SBWatchpoint::GetWatchpointEventTypeFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_GetWatchpointFromEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBWatchpoint result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_GetWatchpointFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SBWatchpoint_GetWatchpointFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb::SBWatchpoint::GetWatchpointFromEvent((lldb::SBEvent const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBWatchpoint(result)), SWIGTYPE_p_lldb__SBWatchpoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_GetType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::SBType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_GetType" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->GetType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new lldb::SBType(result)), SWIGTYPE_p_lldb__SBType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_GetWatchValueKind(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::WatchpointValueKind result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_GetWatchValueKind" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::WatchpointValueKind)(arg1)->GetWatchValueKind();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_GetWatchSpec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_GetWatchSpec" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)(arg1)->GetWatchSpec();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_IsWatchingReads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_IsWatchingReads" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsWatchingReads();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint_IsWatchingWrites(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint_IsWatchingWrites" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->IsWatchingWrites();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpoint___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpoint___repr__" "', argument " "1"" of type '" "lldb::SBWatchpoint *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = lldb_SBWatchpoint___repr__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBWatchpoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBWatchpoint, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBWatchpoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBWatchpointOptions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  lldb::SBWatchpointOptions *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBWatchpointOptions *)new lldb::SBWatchpointOptions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBWatchpointOptions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBWatchpointOptions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  lldb::SBWatchpointOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  lldb::SBWatchpointOptions *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_lldb__SBWatchpointOptions,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBWatchpointOptions" "', argument " "1"" of type '" "lldb::SBWatchpointOptions const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SBWatchpointOptions" "', argument " "1"" of type '" "lldb::SBWatchpointOptions const &""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpointOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::SBWatchpointOptions *)new lldb::SBWatchpointOptions((lldb::SBWatchpointOptions const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBWatchpointOptions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBWatchpointOptions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBWatchpointOptions", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBWatchpointOptions__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBWatchpointOptions, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBWatchpointOptions__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBWatchpointOptions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    lldb::SBWatchpointOptions::SBWatchpointOptions()\n"
    "    lldb::SBWatchpointOptions::SBWatchpointOptions(lldb::SBWatchpointOptions const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBWatchpointOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpointOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpointOptions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBWatchpointOptions" "', argument " "1"" of type '" "lldb::SBWatchpointOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpointOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpointOptions_SetWatchpointTypeRead(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpointOptions *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBWatchpointOptions_SetWatchpointTypeRead", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpointOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpointOptions_SetWatchpointTypeRead" "', argument " "1"" of type '" "lldb::SBWatchpointOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpointOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBWatchpointOptions_SetWatchpointTypeRead" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetWatchpointTypeRead(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpointOptions_GetWatchpointTypeRead(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpointOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpointOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpointOptions_GetWatchpointTypeRead" "', argument " "1"" of type '" "lldb::SBWatchpointOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpointOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((lldb::SBWatchpointOptions const *)arg1)->GetWatchpointTypeRead();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpointOptions_SetWatchpointTypeWrite(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpointOptions *arg1 = 0 ;
  lldb::WatchpointWriteType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SBWatchpointOptions_SetWatchpointTypeWrite", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpointOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpointOptions_SetWatchpointTypeWrite" "', argument " "1"" of type '" "lldb::SBWatchpointOptions *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpointOptions * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBWatchpointOptions_SetWatchpointTypeWrite" "', argument " "2"" of type '" "lldb::WatchpointWriteType""'");
  } 
  arg2 = static_cast< lldb::WatchpointWriteType >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->SetWatchpointTypeWrite(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBWatchpointOptions_GetWatchpointTypeWrite(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  lldb::SBWatchpointOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  lldb::WatchpointWriteType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_lldb__SBWatchpointOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBWatchpointOptions_GetWatchpointTypeWrite" "', argument " "1"" of type '" "lldb::SBWatchpointOptions const *""'"); 
  }
  arg1 = reinterpret_cast< lldb::SBWatchpointOptions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (lldb::WatchpointWriteType)((lldb::SBWatchpointOptions const *)arg1)->GetWatchpointTypeWrite();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBWatchpointOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBWatchpointOptions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBWatchpointOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

static PyMethodDef SwigMethods[] = {
	 { "new_SBAddress", _wrap_new_SBAddress, METH_VARARGS, "\n"
		"SBAddress()\n"
		"SBAddress(SBAddress rhs)\n"
		"SBAddress(SBSection section, lldb::addr_t offset)\n"
		"new_SBAddress(lldb::addr_t load_addr, SBTarget target) -> SBAddress\n"
		"\n"
		"    Create an address by resolving a load address using the supplied target.\n"
		""},
	 { "delete_SBAddress", _wrap_delete_SBAddress, METH_O, "delete_SBAddress(SBAddress self)"},
	 { "SBAddress___nonzero__", _wrap_SBAddress___nonzero__, METH_O, "SBAddress___nonzero__(SBAddress self) -> bool"},
	 { "SBAddress___ne__", _wrap_SBAddress___ne__, METH_VARARGS, "SBAddress___ne__(SBAddress self, SBAddress rhs) -> bool"},
	 { "SBAddress_IsValid", _wrap_SBAddress_IsValid, METH_O, "SBAddress_IsValid(SBAddress self) -> bool"},
	 { "SBAddress_Clear", _wrap_SBAddress_Clear, METH_O, "SBAddress_Clear(SBAddress self)"},
	 { "SBAddress_GetFileAddress", _wrap_SBAddress_GetFileAddress, METH_O, "SBAddress_GetFileAddress(SBAddress self) -> lldb::addr_t"},
	 { "SBAddress_GetLoadAddress", _wrap_SBAddress_GetLoadAddress, METH_VARARGS, "SBAddress_GetLoadAddress(SBAddress self, SBTarget target) -> lldb::addr_t"},
	 { "SBAddress_SetAddress", _wrap_SBAddress_SetAddress, METH_VARARGS, "SBAddress_SetAddress(SBAddress self, SBSection section, lldb::addr_t offset)"},
	 { "SBAddress_SetLoadAddress", _wrap_SBAddress_SetLoadAddress, METH_VARARGS, "SBAddress_SetLoadAddress(SBAddress self, lldb::addr_t load_addr, SBTarget target)"},
	 { "SBAddress_OffsetAddress", _wrap_SBAddress_OffsetAddress, METH_VARARGS, "SBAddress_OffsetAddress(SBAddress self, lldb::addr_t offset) -> bool"},
	 { "SBAddress_GetDescription", _wrap_SBAddress_GetDescription, METH_VARARGS, "SBAddress_GetDescription(SBAddress self, SBStream description) -> bool"},
	 { "SBAddress_GetSymbolContext", _wrap_SBAddress_GetSymbolContext, METH_VARARGS, "\n"
		"SBAddress_GetSymbolContext(SBAddress self, uint32_t resolve_scope) -> SBSymbolContext\n"
		"\n"
		"    GetSymbolContext() and the following can lookup symbol information for a given address.\n"
		"    An address might refer to code or data from an existing module, or it\n"
		"    might refer to something on the stack or heap. The following functions\n"
		"    will only return valid values if the address has been resolved to a code\n"
		"    or data address using :py:class:`SBAddress.SetLoadAddress' or\n"
		"    :py:class:`SBTarget.ResolveLoadAddress`.\n"
		""},
	 { "SBAddress_GetSection", _wrap_SBAddress_GetSection, METH_O, "SBAddress_GetSection(SBAddress self) -> SBSection"},
	 { "SBAddress_GetOffset", _wrap_SBAddress_GetOffset, METH_O, "SBAddress_GetOffset(SBAddress self) -> lldb::addr_t"},
	 { "SBAddress_GetModule", _wrap_SBAddress_GetModule, METH_O, "\n"
		"SBAddress_GetModule(SBAddress self) -> SBModule\n"
		"\n"
		"    GetModule() and the following grab individual objects for a given address and\n"
		"    are less efficient if you want more than one symbol related objects.\n"
		"    Use :py:class:`SBAddress.GetSymbolContext` or\n"
		"    :py:class:`SBTarget.ResolveSymbolContextForAddress` when you want multiple\n"
		"    debug symbol related objects for an address.\n"
		"    One or more bits from the SymbolContextItem enumerations can be logically\n"
		"    OR'ed together to more efficiently retrieve multiple symbol objects.\n"
		""},
	 { "SBAddress_GetCompileUnit", _wrap_SBAddress_GetCompileUnit, METH_O, "SBAddress_GetCompileUnit(SBAddress self) -> SBCompileUnit"},
	 { "SBAddress_GetFunction", _wrap_SBAddress_GetFunction, METH_O, "SBAddress_GetFunction(SBAddress self) -> SBFunction"},
	 { "SBAddress_GetBlock", _wrap_SBAddress_GetBlock, METH_O, "SBAddress_GetBlock(SBAddress self) -> SBBlock"},
	 { "SBAddress_GetSymbol", _wrap_SBAddress_GetSymbol, METH_O, "SBAddress_GetSymbol(SBAddress self) -> SBSymbol"},
	 { "SBAddress_GetLineEntry", _wrap_SBAddress_GetLineEntry, METH_O, "SBAddress_GetLineEntry(SBAddress self) -> SBLineEntry"},
	 { "SBAddress___repr__", _wrap_SBAddress___repr__, METH_O, "SBAddress___repr__(SBAddress self) -> std::string"},
	 { "SBAddress_swigregister", SBAddress_swigregister, METH_O, NULL},
	 { "SBAddress_swiginit", SBAddress_swiginit, METH_VARARGS, NULL},
	 { "new_SBAddressRange", _wrap_new_SBAddressRange, METH_VARARGS, "\n"
		"SBAddressRange()\n"
		"SBAddressRange(SBAddressRange rhs)\n"
		"new_SBAddressRange(SBAddress addr, lldb::addr_t byte_size) -> SBAddressRange\n"
		""},
	 { "delete_SBAddressRange", _wrap_delete_SBAddressRange, METH_O, "delete_SBAddressRange(SBAddressRange self)"},
	 { "SBAddressRange_Clear", _wrap_SBAddressRange_Clear, METH_O, "SBAddressRange_Clear(SBAddressRange self)"},
	 { "SBAddressRange_IsValid", _wrap_SBAddressRange_IsValid, METH_O, "\n"
		"Check the address range refers to a valid base address and has a byte\n"
		"size greater than zero.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"        True if the address range is valid, false otherwise.\n"
		""},
	 { "SBAddressRange_GetBaseAddress", _wrap_SBAddressRange_GetBaseAddress, METH_O, "\n"
		"Get the base address of the range.\n"
		"\n"
		":rtype: :py:class:`SBAddress`\n"
		":return: \n"
		"        Base address object.\n"
		""},
	 { "SBAddressRange_GetByteSize", _wrap_SBAddressRange_GetByteSize, METH_O, "\n"
		"Get the byte size of this range.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"        The size in bytes of this address range.\n"
		""},
	 { "SBAddressRange___eq__", _wrap_SBAddressRange___eq__, METH_VARARGS, "SBAddressRange___eq__(SBAddressRange self, SBAddressRange rhs) -> bool"},
	 { "SBAddressRange___ne__", _wrap_SBAddressRange___ne__, METH_VARARGS, "SBAddressRange___ne__(SBAddressRange self, SBAddressRange rhs) -> bool"},
	 { "SBAddressRange_GetDescription", _wrap_SBAddressRange_GetDescription, METH_VARARGS, "SBAddressRange_GetDescription(SBAddressRange self, SBStream description, SBTarget target) -> bool"},
	 { "SBAddressRange_swigregister", SBAddressRange_swigregister, METH_O, NULL},
	 { "SBAddressRange_swiginit", SBAddressRange_swiginit, METH_VARARGS, NULL},
	 { "new_SBAddressRangeList", _wrap_new_SBAddressRangeList, METH_VARARGS, "\n"
		"SBAddressRangeList()\n"
		"new_SBAddressRangeList(SBAddressRangeList rhs) -> SBAddressRangeList\n"
		""},
	 { "delete_SBAddressRangeList", _wrap_delete_SBAddressRangeList, METH_O, "delete_SBAddressRangeList(SBAddressRangeList self)"},
	 { "SBAddressRangeList_GetSize", _wrap_SBAddressRangeList_GetSize, METH_O, "SBAddressRangeList_GetSize(SBAddressRangeList self) -> uint32_t"},
	 { "SBAddressRangeList_Clear", _wrap_SBAddressRangeList_Clear, METH_O, "SBAddressRangeList_Clear(SBAddressRangeList self)"},
	 { "SBAddressRangeList_GetAddressRangeAtIndex", _wrap_SBAddressRangeList_GetAddressRangeAtIndex, METH_VARARGS, "SBAddressRangeList_GetAddressRangeAtIndex(SBAddressRangeList self, uint64_t idx) -> SBAddressRange"},
	 { "SBAddressRangeList_Append", _wrap_SBAddressRangeList_Append, METH_VARARGS, "\n"
		"SBAddressRangeList_Append(SBAddressRangeList self, SBAddressRange addr_range)\n"
		"SBAddressRangeList_Append(SBAddressRangeList self, SBAddressRangeList addr_range_list)\n"
		""},
	 { "SBAddressRangeList_GetDescription", _wrap_SBAddressRangeList_GetDescription, METH_VARARGS, "SBAddressRangeList_GetDescription(SBAddressRangeList self, SBStream description, SBTarget target) -> bool"},
	 { "SBAddressRangeList_swigregister", SBAddressRangeList_swigregister, METH_O, NULL},
	 { "SBAddressRangeList_swiginit", SBAddressRangeList_swiginit, METH_VARARGS, NULL},
	 { "new_SBAttachInfo", _wrap_new_SBAttachInfo, METH_VARARGS, "\n"
		"SBAttachInfo()\n"
		"SBAttachInfo(lldb::pid_t pid)\n"
		"SBAttachInfo(char const * path, bool wait_for)\n"
		"SBAttachInfo(char const * path, bool wait_for, bool _async)\n"
		"new_SBAttachInfo(SBAttachInfo rhs) -> SBAttachInfo\n"
		""},
	 { "delete_SBAttachInfo", _wrap_delete_SBAttachInfo, METH_O, "delete_SBAttachInfo(SBAttachInfo self)"},
	 { "SBAttachInfo_GetProcessID", _wrap_SBAttachInfo_GetProcessID, METH_O, "SBAttachInfo_GetProcessID(SBAttachInfo self) -> lldb::pid_t"},
	 { "SBAttachInfo_SetProcessID", _wrap_SBAttachInfo_SetProcessID, METH_VARARGS, "SBAttachInfo_SetProcessID(SBAttachInfo self, lldb::pid_t pid)"},
	 { "SBAttachInfo_SetExecutable", _wrap_SBAttachInfo_SetExecutable, METH_VARARGS, "\n"
		"SBAttachInfo_SetExecutable(SBAttachInfo self, char const * path)\n"
		"SBAttachInfo_SetExecutable(SBAttachInfo self, SBFileSpec exe_file)\n"
		""},
	 { "SBAttachInfo_GetWaitForLaunch", _wrap_SBAttachInfo_GetWaitForLaunch, METH_O, "SBAttachInfo_GetWaitForLaunch(SBAttachInfo self) -> bool"},
	 { "SBAttachInfo_SetWaitForLaunch", _wrap_SBAttachInfo_SetWaitForLaunch, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		"Set attach by process name settings.\n"
		"\n"
		"Designed to be used after a call to SBAttachInfo::SetExecutable().\n"
		"This function implies that a call to SBTarget::Attach(...) will\n"
		"be synchronous.\n"
		"\n"
		":type b: boolean, in\n"
		":param b:\n"
		"        If **false**, attach to an existing process whose name matches.\n"
		"        If **true**, then wait for the next process whose name matches.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		"Set attach by process name settings.\n"
		"\n"
		"Designed to be used after a call to SBAttachInfo::SetExecutable().\n"
		"Future calls to SBTarget::Attach(...) will be synchronous or\n"
		"asynchronous depending on the *async* argument.\n"
		"\n"
		":type b: boolean, in\n"
		":param b:\n"
		"        If **false**, attach to an existing process whose name matches.\n"
		"        If **true**, then wait for the next process whose name matches.\n"
		"\n"
		":type async: boolean, in\n"
		":param async:\n"
		"        If **false**, then the SBTarget::Attach(...) call will be a\n"
		"        synchronous call with no way to cancel the attach in\n"
		"        progress.\n"
		"        If **true**, then the SBTarget::Attach(...) function will\n"
		"        return immediately and clients are expected to wait for a\n"
		"        process eStateStopped event if a suitable process is\n"
		"        eventually found. If the client wants to cancel the event,\n"
		"        SBProcess::Stop() can be called and an eStateExited process\n"
		"        event will be delivered.\n"
		""},
	 { "SBAttachInfo_GetIgnoreExisting", _wrap_SBAttachInfo_GetIgnoreExisting, METH_O, "SBAttachInfo_GetIgnoreExisting(SBAttachInfo self) -> bool"},
	 { "SBAttachInfo_SetIgnoreExisting", _wrap_SBAttachInfo_SetIgnoreExisting, METH_VARARGS, "SBAttachInfo_SetIgnoreExisting(SBAttachInfo self, bool b)"},
	 { "SBAttachInfo_GetResumeCount", _wrap_SBAttachInfo_GetResumeCount, METH_O, "SBAttachInfo_GetResumeCount(SBAttachInfo self) -> uint32_t"},
	 { "SBAttachInfo_SetResumeCount", _wrap_SBAttachInfo_SetResumeCount, METH_VARARGS, "SBAttachInfo_SetResumeCount(SBAttachInfo self, uint32_t c)"},
	 { "SBAttachInfo_GetProcessPluginName", _wrap_SBAttachInfo_GetProcessPluginName, METH_O, "SBAttachInfo_GetProcessPluginName(SBAttachInfo self) -> char const *"},
	 { "SBAttachInfo_SetProcessPluginName", _wrap_SBAttachInfo_SetProcessPluginName, METH_VARARGS, "SBAttachInfo_SetProcessPluginName(SBAttachInfo self, char const * plugin_name)"},
	 { "SBAttachInfo_GetUserID", _wrap_SBAttachInfo_GetUserID, METH_O, "SBAttachInfo_GetUserID(SBAttachInfo self) -> uint32_t"},
	 { "SBAttachInfo_GetGroupID", _wrap_SBAttachInfo_GetGroupID, METH_O, "SBAttachInfo_GetGroupID(SBAttachInfo self) -> uint32_t"},
	 { "SBAttachInfo_UserIDIsValid", _wrap_SBAttachInfo_UserIDIsValid, METH_O, "SBAttachInfo_UserIDIsValid(SBAttachInfo self) -> bool"},
	 { "SBAttachInfo_GroupIDIsValid", _wrap_SBAttachInfo_GroupIDIsValid, METH_O, "SBAttachInfo_GroupIDIsValid(SBAttachInfo self) -> bool"},
	 { "SBAttachInfo_SetUserID", _wrap_SBAttachInfo_SetUserID, METH_VARARGS, "SBAttachInfo_SetUserID(SBAttachInfo self, uint32_t uid)"},
	 { "SBAttachInfo_SetGroupID", _wrap_SBAttachInfo_SetGroupID, METH_VARARGS, "SBAttachInfo_SetGroupID(SBAttachInfo self, uint32_t gid)"},
	 { "SBAttachInfo_GetEffectiveUserID", _wrap_SBAttachInfo_GetEffectiveUserID, METH_O, "SBAttachInfo_GetEffectiveUserID(SBAttachInfo self) -> uint32_t"},
	 { "SBAttachInfo_GetEffectiveGroupID", _wrap_SBAttachInfo_GetEffectiveGroupID, METH_O, "SBAttachInfo_GetEffectiveGroupID(SBAttachInfo self) -> uint32_t"},
	 { "SBAttachInfo_EffectiveUserIDIsValid", _wrap_SBAttachInfo_EffectiveUserIDIsValid, METH_O, "SBAttachInfo_EffectiveUserIDIsValid(SBAttachInfo self) -> bool"},
	 { "SBAttachInfo_EffectiveGroupIDIsValid", _wrap_SBAttachInfo_EffectiveGroupIDIsValid, METH_O, "SBAttachInfo_EffectiveGroupIDIsValid(SBAttachInfo self) -> bool"},
	 { "SBAttachInfo_SetEffectiveUserID", _wrap_SBAttachInfo_SetEffectiveUserID, METH_VARARGS, "SBAttachInfo_SetEffectiveUserID(SBAttachInfo self, uint32_t uid)"},
	 { "SBAttachInfo_SetEffectiveGroupID", _wrap_SBAttachInfo_SetEffectiveGroupID, METH_VARARGS, "SBAttachInfo_SetEffectiveGroupID(SBAttachInfo self, uint32_t gid)"},
	 { "SBAttachInfo_GetParentProcessID", _wrap_SBAttachInfo_GetParentProcessID, METH_O, "SBAttachInfo_GetParentProcessID(SBAttachInfo self) -> lldb::pid_t"},
	 { "SBAttachInfo_SetParentProcessID", _wrap_SBAttachInfo_SetParentProcessID, METH_VARARGS, "SBAttachInfo_SetParentProcessID(SBAttachInfo self, lldb::pid_t pid)"},
	 { "SBAttachInfo_ParentProcessIDIsValid", _wrap_SBAttachInfo_ParentProcessIDIsValid, METH_O, "SBAttachInfo_ParentProcessIDIsValid(SBAttachInfo self) -> bool"},
	 { "SBAttachInfo_GetListener", _wrap_SBAttachInfo_GetListener, METH_O, "\n"
		"Get the listener that will be used to receive process events.\n"
		"\n"
		"If no listener has been set via a call to\n"
		"SBAttachInfo::SetListener(), then an invalid SBListener will be\n"
		"returned (SBListener::IsValid() will return false). If a listener\n"
		"has been set, then the valid listener object will be returned.\n"
		""},
	 { "SBAttachInfo_SetListener", _wrap_SBAttachInfo_SetListener, METH_VARARGS, "\n"
		"Set the listener that will be used to receive process events.\n"
		"\n"
		"By default the SBDebugger, which has a listener, that the SBTarget\n"
		"belongs to will listen for the process events. Calling this function\n"
		"allows a different listener to be used to listen for process events.\n"
		""},
	 { "SBAttachInfo_GetShadowListener", _wrap_SBAttachInfo_GetShadowListener, METH_O, "\n"
		"Get the shadow listener that receive public process events,\n"
		"additionally to the default process event listener.\n"
		"\n"
		"If no listener has been set via a call to\n"
		"SBLaunchInfo::SetShadowListener(), then an invalid SBListener will\n"
		"be returned (SBListener::IsValid() will return false). If a listener\n"
		"has been set, then the valid listener object will be returned.\n"
		""},
	 { "SBAttachInfo_SetShadowListener", _wrap_SBAttachInfo_SetShadowListener, METH_VARARGS, "\n"
		"Set the shadow listener that will receive public process events,\n"
		"additionally to the default process event listener.\n"
		"\n"
		"By default a process have no shadow event listener.\n"
		"Calling this function allows public process events to be broadcasted to an\n"
		"additional listener on top of the default process event listener.\n"
		"If the `listener` argument is invalid (SBListener::IsValid() will\n"
		"return false), this will clear the shadow listener.\n"
		""},
	 { "SBAttachInfo_GetScriptedProcessClassName", _wrap_SBAttachInfo_GetScriptedProcessClassName, METH_O, "SBAttachInfo_GetScriptedProcessClassName(SBAttachInfo self) -> char const *"},
	 { "SBAttachInfo_SetScriptedProcessClassName", _wrap_SBAttachInfo_SetScriptedProcessClassName, METH_VARARGS, "SBAttachInfo_SetScriptedProcessClassName(SBAttachInfo self, char const * class_name)"},
	 { "SBAttachInfo_GetScriptedProcessDictionary", _wrap_SBAttachInfo_GetScriptedProcessDictionary, METH_O, "SBAttachInfo_GetScriptedProcessDictionary(SBAttachInfo self) -> SBStructuredData"},
	 { "SBAttachInfo_SetScriptedProcessDictionary", _wrap_SBAttachInfo_SetScriptedProcessDictionary, METH_VARARGS, "SBAttachInfo_SetScriptedProcessDictionary(SBAttachInfo self, SBStructuredData dict)"},
	 { "SBAttachInfo_swigregister", SBAttachInfo_swigregister, METH_O, NULL},
	 { "SBAttachInfo_swiginit", SBAttachInfo_swiginit, METH_VARARGS, NULL},
	 { "new_SBBlock", _wrap_new_SBBlock, METH_VARARGS, "\n"
		"SBBlock()\n"
		"new_SBBlock(SBBlock rhs) -> SBBlock\n"
		""},
	 { "delete_SBBlock", _wrap_delete_SBBlock, METH_O, "delete_SBBlock(SBBlock self)"},
	 { "SBBlock_IsInlined", _wrap_SBBlock_IsInlined, METH_O, "\n"
		"SBBlock_IsInlined(SBBlock self) -> bool\n"
		"Is this block contained within an inlined function?\n"
		""},
	 { "SBBlock___nonzero__", _wrap_SBBlock___nonzero__, METH_O, "SBBlock___nonzero__(SBBlock self) -> bool"},
	 { "SBBlock_IsValid", _wrap_SBBlock_IsValid, METH_O, "SBBlock_IsValid(SBBlock self) -> bool"},
	 { "SBBlock_GetInlinedName", _wrap_SBBlock_GetInlinedName, METH_O, "\n"
		"SBBlock_GetInlinedName(SBBlock self) -> char const *\n"
		"\n"
		"    Get the function name if this block represents an inlined function;\n"
		"    otherwise, return None.\n"
		""},
	 { "SBBlock_GetInlinedCallSiteFile", _wrap_SBBlock_GetInlinedCallSiteFile, METH_O, "\n"
		"SBBlock_GetInlinedCallSiteFile(SBBlock self) -> SBFileSpec\n"
		"\n"
		"    Get the call site file if this block represents an inlined function;\n"
		"    otherwise, return an invalid file spec.\n"
		""},
	 { "SBBlock_GetInlinedCallSiteLine", _wrap_SBBlock_GetInlinedCallSiteLine, METH_O, "\n"
		"SBBlock_GetInlinedCallSiteLine(SBBlock self) -> uint32_t\n"
		"\n"
		"    Get the call site line if this block represents an inlined function;\n"
		"    otherwise, return 0.\n"
		""},
	 { "SBBlock_GetInlinedCallSiteColumn", _wrap_SBBlock_GetInlinedCallSiteColumn, METH_O, "\n"
		"SBBlock_GetInlinedCallSiteColumn(SBBlock self) -> uint32_t\n"
		"\n"
		"    Get the call site column if this block represents an inlined function;\n"
		"    otherwise, return 0.\n"
		""},
	 { "SBBlock_GetParent", _wrap_SBBlock_GetParent, METH_O, "\n"
		"SBBlock_GetParent(SBBlock self) -> SBBlock\n"
		"Get the parent block.\n"
		""},
	 { "SBBlock_GetSibling", _wrap_SBBlock_GetSibling, METH_O, "\n"
		"SBBlock_GetSibling(SBBlock self) -> SBBlock\n"
		"Get the sibling block for this block.\n"
		""},
	 { "SBBlock_GetFirstChild", _wrap_SBBlock_GetFirstChild, METH_O, "\n"
		"SBBlock_GetFirstChild(SBBlock self) -> SBBlock\n"
		"Get the first child block.\n"
		""},
	 { "SBBlock_GetNumRanges", _wrap_SBBlock_GetNumRanges, METH_O, "SBBlock_GetNumRanges(SBBlock self) -> uint32_t"},
	 { "SBBlock_GetRangeStartAddress", _wrap_SBBlock_GetRangeStartAddress, METH_VARARGS, "SBBlock_GetRangeStartAddress(SBBlock self, uint32_t idx) -> SBAddress"},
	 { "SBBlock_GetRangeEndAddress", _wrap_SBBlock_GetRangeEndAddress, METH_VARARGS, "SBBlock_GetRangeEndAddress(SBBlock self, uint32_t idx) -> SBAddress"},
	 { "SBBlock_GetRanges", _wrap_SBBlock_GetRanges, METH_O, "SBBlock_GetRanges(SBBlock self) -> SBAddressRangeList"},
	 { "SBBlock_GetRangeIndexForBlockAddress", _wrap_SBBlock_GetRangeIndexForBlockAddress, METH_VARARGS, "SBBlock_GetRangeIndexForBlockAddress(SBBlock self, SBAddress block_addr) -> uint32_t"},
	 { "SBBlock_GetVariables", _wrap_SBBlock_GetVariables, METH_VARARGS, "\n"
		"SBBlock_GetVariables(SBBlock self, SBFrame frame, bool arguments, bool locals, bool statics, lldb::DynamicValueType use_dynamic) -> SBValueList\n"
		"SBBlock_GetVariables(SBBlock self, SBTarget target, bool arguments, bool locals, bool statics) -> SBValueList\n"
		""},
	 { "SBBlock_GetContainingInlinedBlock", _wrap_SBBlock_GetContainingInlinedBlock, METH_O, "\n"
		"SBBlock_GetContainingInlinedBlock(SBBlock self) -> SBBlock\n"
		"Get the inlined block that is or contains this block.\n"
		""},
	 { "SBBlock_GetDescription", _wrap_SBBlock_GetDescription, METH_VARARGS, "SBBlock_GetDescription(SBBlock self, SBStream description) -> bool"},
	 { "SBBlock___repr__", _wrap_SBBlock___repr__, METH_O, "SBBlock___repr__(SBBlock self) -> std::string"},
	 { "SBBlock_swigregister", SBBlock_swigregister, METH_O, NULL},
	 { "SBBlock_swiginit", SBBlock_swiginit, METH_VARARGS, NULL},
	 { "new_SBBreakpoint", _wrap_new_SBBreakpoint, METH_VARARGS, "\n"
		"SBBreakpoint()\n"
		"new_SBBreakpoint(SBBreakpoint rhs) -> SBBreakpoint\n"
		""},
	 { "delete_SBBreakpoint", _wrap_delete_SBBreakpoint, METH_O, "delete_SBBreakpoint(SBBreakpoint self)"},
	 { "SBBreakpoint___eq__", _wrap_SBBreakpoint___eq__, METH_VARARGS, "SBBreakpoint___eq__(SBBreakpoint self, SBBreakpoint rhs) -> bool"},
	 { "SBBreakpoint___ne__", _wrap_SBBreakpoint___ne__, METH_VARARGS, "SBBreakpoint___ne__(SBBreakpoint self, SBBreakpoint rhs) -> bool"},
	 { "SBBreakpoint_GetID", _wrap_SBBreakpoint_GetID, METH_O, "SBBreakpoint_GetID(SBBreakpoint self) -> lldb::break_id_t"},
	 { "SBBreakpoint___nonzero__", _wrap_SBBreakpoint___nonzero__, METH_O, "SBBreakpoint___nonzero__(SBBreakpoint self) -> bool"},
	 { "SBBreakpoint_IsValid", _wrap_SBBreakpoint_IsValid, METH_O, "SBBreakpoint_IsValid(SBBreakpoint self) -> bool"},
	 { "SBBreakpoint_ClearAllBreakpointSites", _wrap_SBBreakpoint_ClearAllBreakpointSites, METH_O, "SBBreakpoint_ClearAllBreakpointSites(SBBreakpoint self)"},
	 { "SBBreakpoint_GetTarget", _wrap_SBBreakpoint_GetTarget, METH_O, "SBBreakpoint_GetTarget(SBBreakpoint self) -> SBTarget"},
	 { "SBBreakpoint_FindLocationByAddress", _wrap_SBBreakpoint_FindLocationByAddress, METH_VARARGS, "SBBreakpoint_FindLocationByAddress(SBBreakpoint self, lldb::addr_t vm_addr) -> SBBreakpointLocation"},
	 { "SBBreakpoint_FindLocationIDByAddress", _wrap_SBBreakpoint_FindLocationIDByAddress, METH_VARARGS, "SBBreakpoint_FindLocationIDByAddress(SBBreakpoint self, lldb::addr_t vm_addr) -> lldb::break_id_t"},
	 { "SBBreakpoint_FindLocationByID", _wrap_SBBreakpoint_FindLocationByID, METH_VARARGS, "SBBreakpoint_FindLocationByID(SBBreakpoint self, lldb::break_id_t bp_loc_id) -> SBBreakpointLocation"},
	 { "SBBreakpoint_GetLocationAtIndex", _wrap_SBBreakpoint_GetLocationAtIndex, METH_VARARGS, "SBBreakpoint_GetLocationAtIndex(SBBreakpoint self, uint32_t index) -> SBBreakpointLocation"},
	 { "SBBreakpoint_SetEnabled", _wrap_SBBreakpoint_SetEnabled, METH_VARARGS, "SBBreakpoint_SetEnabled(SBBreakpoint self, bool enable)"},
	 { "SBBreakpoint_IsEnabled", _wrap_SBBreakpoint_IsEnabled, METH_O, "SBBreakpoint_IsEnabled(SBBreakpoint self) -> bool"},
	 { "SBBreakpoint_SetOneShot", _wrap_SBBreakpoint_SetOneShot, METH_VARARGS, "SBBreakpoint_SetOneShot(SBBreakpoint self, bool one_shot)"},
	 { "SBBreakpoint_IsOneShot", _wrap_SBBreakpoint_IsOneShot, METH_O, "SBBreakpoint_IsOneShot(SBBreakpoint self) -> bool"},
	 { "SBBreakpoint_IsInternal", _wrap_SBBreakpoint_IsInternal, METH_O, "SBBreakpoint_IsInternal(SBBreakpoint self) -> bool"},
	 { "SBBreakpoint_GetHitCount", _wrap_SBBreakpoint_GetHitCount, METH_O, "SBBreakpoint_GetHitCount(SBBreakpoint self) -> uint32_t"},
	 { "SBBreakpoint_SetIgnoreCount", _wrap_SBBreakpoint_SetIgnoreCount, METH_VARARGS, "SBBreakpoint_SetIgnoreCount(SBBreakpoint self, uint32_t count)"},
	 { "SBBreakpoint_GetIgnoreCount", _wrap_SBBreakpoint_GetIgnoreCount, METH_O, "SBBreakpoint_GetIgnoreCount(SBBreakpoint self) -> uint32_t"},
	 { "SBBreakpoint_SetCondition", _wrap_SBBreakpoint_SetCondition, METH_VARARGS, "\n"
		"SBBreakpoint_SetCondition(SBBreakpoint self, char const * condition)\n"
		"\n"
		"    The breakpoint stops only if the condition expression evaluates to true.\n"
		""},
	 { "SBBreakpoint_GetCondition", _wrap_SBBreakpoint_GetCondition, METH_O, "\n"
		"SBBreakpoint_GetCondition(SBBreakpoint self) -> char const *\n"
		"\n"
		"    Get the condition expression for the breakpoint.\n"
		""},
	 { "SBBreakpoint_SetAutoContinue", _wrap_SBBreakpoint_SetAutoContinue, METH_VARARGS, "SBBreakpoint_SetAutoContinue(SBBreakpoint self, bool auto_continue)"},
	 { "SBBreakpoint_GetAutoContinue", _wrap_SBBreakpoint_GetAutoContinue, METH_O, "SBBreakpoint_GetAutoContinue(SBBreakpoint self) -> bool"},
	 { "SBBreakpoint_SetThreadID", _wrap_SBBreakpoint_SetThreadID, METH_VARARGS, "SBBreakpoint_SetThreadID(SBBreakpoint self, lldb::tid_t sb_thread_id)"},
	 { "SBBreakpoint_GetThreadID", _wrap_SBBreakpoint_GetThreadID, METH_O, "SBBreakpoint_GetThreadID(SBBreakpoint self) -> lldb::tid_t"},
	 { "SBBreakpoint_SetThreadIndex", _wrap_SBBreakpoint_SetThreadIndex, METH_VARARGS, "SBBreakpoint_SetThreadIndex(SBBreakpoint self, uint32_t index)"},
	 { "SBBreakpoint_GetThreadIndex", _wrap_SBBreakpoint_GetThreadIndex, METH_O, "SBBreakpoint_GetThreadIndex(SBBreakpoint self) -> uint32_t"},
	 { "SBBreakpoint_SetThreadName", _wrap_SBBreakpoint_SetThreadName, METH_VARARGS, "SBBreakpoint_SetThreadName(SBBreakpoint self, char const * thread_name)"},
	 { "SBBreakpoint_GetThreadName", _wrap_SBBreakpoint_GetThreadName, METH_O, "SBBreakpoint_GetThreadName(SBBreakpoint self) -> char const *"},
	 { "SBBreakpoint_SetQueueName", _wrap_SBBreakpoint_SetQueueName, METH_VARARGS, "SBBreakpoint_SetQueueName(SBBreakpoint self, char const * queue_name)"},
	 { "SBBreakpoint_GetQueueName", _wrap_SBBreakpoint_GetQueueName, METH_O, "SBBreakpoint_GetQueueName(SBBreakpoint self) -> char const *"},
	 { "SBBreakpoint_SetScriptCallbackFunction", _wrap_SBBreakpoint_SetScriptCallbackFunction, METH_VARARGS, "\n"
		"SBBreakpoint_SetScriptCallbackFunction(SBBreakpoint self, char const * callback_function_name)\n"
		"SBBreakpoint_SetScriptCallbackFunction(SBBreakpoint self, char const * callback_function_name, SBStructuredData extra_args) -> SBError\n"
		"\n"
		"    Set the name of the script function to be called when the breakpoint is hit.\n"
		"    To use this variant, the function should take (frame, bp_loc, extra_args, internal_dict) and\n"
		"    when the breakpoint is hit the extra_args will be passed to the callback function.\n"
		""},
	 { "SBBreakpoint_SetCommandLineCommands", _wrap_SBBreakpoint_SetCommandLineCommands, METH_VARARGS, "SBBreakpoint_SetCommandLineCommands(SBBreakpoint self, SBStringList commands)"},
	 { "SBBreakpoint_GetCommandLineCommands", _wrap_SBBreakpoint_GetCommandLineCommands, METH_VARARGS, "SBBreakpoint_GetCommandLineCommands(SBBreakpoint self, SBStringList commands) -> bool"},
	 { "SBBreakpoint_SetScriptCallbackBody", _wrap_SBBreakpoint_SetScriptCallbackBody, METH_VARARGS, "\n"
		"SBBreakpoint_SetScriptCallbackBody(SBBreakpoint self, char const * script_body_text) -> SBError\n"
		"\n"
		"    Provide the body for the script function to be called when the breakpoint is hit.\n"
		"    The body will be wrapped in a function, which be passed two arguments:\n"
		"    'frame' - which holds the bottom-most SBFrame of the thread that hit the breakpoint\n"
		"    'bpno'  - which is the SBBreakpointLocation to which the callback was attached.\n"
		"\n"
		"    The error parameter is currently ignored, but will at some point hold the Python\n"
		"    compilation diagnostics.\n"
		"    Returns true if the body compiles successfully, false if not.\n"
		""},
	 { "SBBreakpoint_AddName", _wrap_SBBreakpoint_AddName, METH_VARARGS, "SBBreakpoint_AddName(SBBreakpoint self, char const * new_name) -> bool"},
	 { "SBBreakpoint_AddNameWithErrorHandling", _wrap_SBBreakpoint_AddNameWithErrorHandling, METH_VARARGS, "SBBreakpoint_AddNameWithErrorHandling(SBBreakpoint self, char const * new_name) -> SBError"},
	 { "SBBreakpoint_RemoveName", _wrap_SBBreakpoint_RemoveName, METH_VARARGS, "SBBreakpoint_RemoveName(SBBreakpoint self, char const * name_to_remove)"},
	 { "SBBreakpoint_MatchesName", _wrap_SBBreakpoint_MatchesName, METH_VARARGS, "SBBreakpoint_MatchesName(SBBreakpoint self, char const * name) -> bool"},
	 { "SBBreakpoint_GetNames", _wrap_SBBreakpoint_GetNames, METH_VARARGS, "SBBreakpoint_GetNames(SBBreakpoint self, SBStringList names)"},
	 { "SBBreakpoint_GetNumResolvedLocations", _wrap_SBBreakpoint_GetNumResolvedLocations, METH_O, "SBBreakpoint_GetNumResolvedLocations(SBBreakpoint self) -> size_t"},
	 { "SBBreakpoint_GetNumLocations", _wrap_SBBreakpoint_GetNumLocations, METH_O, "SBBreakpoint_GetNumLocations(SBBreakpoint self) -> size_t"},
	 { "SBBreakpoint_GetDescription", _wrap_SBBreakpoint_GetDescription, METH_VARARGS, "\n"
		"SBBreakpoint_GetDescription(SBBreakpoint self, SBStream description) -> bool\n"
		"SBBreakpoint_GetDescription(SBBreakpoint self, SBStream description, bool include_locations) -> bool\n"
		""},
	 { "SBBreakpoint_EventIsBreakpointEvent", _wrap_SBBreakpoint_EventIsBreakpointEvent, METH_O, "SBBreakpoint_EventIsBreakpointEvent(SBEvent event) -> bool"},
	 { "SBBreakpoint_GetBreakpointEventTypeFromEvent", _wrap_SBBreakpoint_GetBreakpointEventTypeFromEvent, METH_O, "SBBreakpoint_GetBreakpointEventTypeFromEvent(SBEvent event) -> lldb::BreakpointEventType"},
	 { "SBBreakpoint_GetBreakpointFromEvent", _wrap_SBBreakpoint_GetBreakpointFromEvent, METH_O, "SBBreakpoint_GetBreakpointFromEvent(SBEvent event) -> SBBreakpoint"},
	 { "SBBreakpoint_GetBreakpointLocationAtIndexFromEvent", _wrap_SBBreakpoint_GetBreakpointLocationAtIndexFromEvent, METH_VARARGS, "SBBreakpoint_GetBreakpointLocationAtIndexFromEvent(SBEvent event, uint32_t loc_idx) -> SBBreakpointLocation"},
	 { "SBBreakpoint_GetNumBreakpointLocationsFromEvent", _wrap_SBBreakpoint_GetNumBreakpointLocationsFromEvent, METH_O, "SBBreakpoint_GetNumBreakpointLocationsFromEvent(SBEvent event_sp) -> uint32_t"},
	 { "SBBreakpoint_IsHardware", _wrap_SBBreakpoint_IsHardware, METH_O, "SBBreakpoint_IsHardware(SBBreakpoint self) -> bool"},
	 { "SBBreakpoint_SetIsHardware", _wrap_SBBreakpoint_SetIsHardware, METH_VARARGS, "\n"
		"Make this breakpoint a hardware breakpoint. This will replace all existing\n"
		"breakpoint locations with hardware breakpoints. Returns an error if this\n"
		"fails, e.g. when there aren't enough hardware resources available.\n"
		""},
	 { "SBBreakpoint_AddLocation", _wrap_SBBreakpoint_AddLocation, METH_VARARGS, "\n"
		"Adds a location to the breakpoint at the address passed in.\n"
		"Can only be called from a ScriptedBreakpointResolver...\n"
		""},
	 { "SBBreakpoint_AddFacadeLocation", _wrap_SBBreakpoint_AddFacadeLocation, METH_O, "\n"
		"Add a \"Facade location\" to the breakpoint.  This returns the Facade\n"
		"Location that was added, which you can then use in\n"
		"get_location_description and was_hit in your breakpoint resolver.\n"
		"Can only be called from a ScriptedBreakpointResolver.\n"
		""},
	 { "SBBreakpoint_SerializeToStructuredData", _wrap_SBBreakpoint_SerializeToStructuredData, METH_O, "SBBreakpoint_SerializeToStructuredData(SBBreakpoint self) -> SBStructuredData"},
	 { "SBBreakpoint___repr__", _wrap_SBBreakpoint___repr__, METH_O, "SBBreakpoint___repr__(SBBreakpoint self) -> std::string"},
	 { "SBBreakpoint_swigregister", SBBreakpoint_swigregister, METH_O, NULL},
	 { "SBBreakpoint_swiginit", SBBreakpoint_swiginit, METH_VARARGS, NULL},
	 { "new_SBBreakpointList", _wrap_new_SBBreakpointList, METH_O, "new_SBBreakpointList(SBTarget target) -> SBBreakpointList"},
	 { "delete_SBBreakpointList", _wrap_delete_SBBreakpointList, METH_O, "delete_SBBreakpointList(SBBreakpointList self)"},
	 { "SBBreakpointList_GetSize", _wrap_SBBreakpointList_GetSize, METH_O, "SBBreakpointList_GetSize(SBBreakpointList self) -> size_t"},
	 { "SBBreakpointList_GetBreakpointAtIndex", _wrap_SBBreakpointList_GetBreakpointAtIndex, METH_VARARGS, "SBBreakpointList_GetBreakpointAtIndex(SBBreakpointList self, size_t idx) -> SBBreakpoint"},
	 { "SBBreakpointList_FindBreakpointByID", _wrap_SBBreakpointList_FindBreakpointByID, METH_VARARGS, "SBBreakpointList_FindBreakpointByID(SBBreakpointList self, lldb::break_id_t arg2) -> SBBreakpoint"},
	 { "SBBreakpointList_Append", _wrap_SBBreakpointList_Append, METH_VARARGS, "SBBreakpointList_Append(SBBreakpointList self, SBBreakpoint sb_bkpt)"},
	 { "SBBreakpointList_AppendIfUnique", _wrap_SBBreakpointList_AppendIfUnique, METH_VARARGS, "SBBreakpointList_AppendIfUnique(SBBreakpointList self, SBBreakpoint sb_bkpt) -> bool"},
	 { "SBBreakpointList_AppendByID", _wrap_SBBreakpointList_AppendByID, METH_VARARGS, "SBBreakpointList_AppendByID(SBBreakpointList self, lldb::break_id_t id)"},
	 { "SBBreakpointList_Clear", _wrap_SBBreakpointList_Clear, METH_O, "SBBreakpointList_Clear(SBBreakpointList self)"},
	 { "SBBreakpointList_swigregister", SBBreakpointList_swigregister, METH_O, NULL},
	 { "SBBreakpointList_swiginit", SBBreakpointList_swiginit, METH_VARARGS, NULL},
	 { "new_SBBreakpointLocation", _wrap_new_SBBreakpointLocation, METH_VARARGS, "\n"
		"SBBreakpointLocation()\n"
		"new_SBBreakpointLocation(SBBreakpointLocation rhs) -> SBBreakpointLocation\n"
		""},
	 { "delete_SBBreakpointLocation", _wrap_delete_SBBreakpointLocation, METH_O, "delete_SBBreakpointLocation(SBBreakpointLocation self)"},
	 { "SBBreakpointLocation_GetID", _wrap_SBBreakpointLocation_GetID, METH_O, "SBBreakpointLocation_GetID(SBBreakpointLocation self) -> lldb::break_id_t"},
	 { "SBBreakpointLocation___nonzero__", _wrap_SBBreakpointLocation___nonzero__, METH_O, "SBBreakpointLocation___nonzero__(SBBreakpointLocation self) -> bool"},
	 { "SBBreakpointLocation_IsValid", _wrap_SBBreakpointLocation_IsValid, METH_O, "SBBreakpointLocation_IsValid(SBBreakpointLocation self) -> bool"},
	 { "SBBreakpointLocation_GetAddress", _wrap_SBBreakpointLocation_GetAddress, METH_O, "SBBreakpointLocation_GetAddress(SBBreakpointLocation self) -> SBAddress"},
	 { "SBBreakpointLocation_GetLoadAddress", _wrap_SBBreakpointLocation_GetLoadAddress, METH_O, "SBBreakpointLocation_GetLoadAddress(SBBreakpointLocation self) -> lldb::addr_t"},
	 { "SBBreakpointLocation_SetEnabled", _wrap_SBBreakpointLocation_SetEnabled, METH_VARARGS, "SBBreakpointLocation_SetEnabled(SBBreakpointLocation self, bool enabled)"},
	 { "SBBreakpointLocation_IsEnabled", _wrap_SBBreakpointLocation_IsEnabled, METH_O, "SBBreakpointLocation_IsEnabled(SBBreakpointLocation self) -> bool"},
	 { "SBBreakpointLocation_GetHitCount", _wrap_SBBreakpointLocation_GetHitCount, METH_O, "SBBreakpointLocation_GetHitCount(SBBreakpointLocation self) -> uint32_t"},
	 { "SBBreakpointLocation_GetIgnoreCount", _wrap_SBBreakpointLocation_GetIgnoreCount, METH_O, "SBBreakpointLocation_GetIgnoreCount(SBBreakpointLocation self) -> uint32_t"},
	 { "SBBreakpointLocation_SetIgnoreCount", _wrap_SBBreakpointLocation_SetIgnoreCount, METH_VARARGS, "SBBreakpointLocation_SetIgnoreCount(SBBreakpointLocation self, uint32_t n)"},
	 { "SBBreakpointLocation_SetCondition", _wrap_SBBreakpointLocation_SetCondition, METH_VARARGS, "\n"
		"SBBreakpointLocation_SetCondition(SBBreakpointLocation self, char const * condition)\n"
		"\n"
		"    The breakpoint location stops only if the condition expression evaluates\n"
		"    to true.\n"
		""},
	 { "SBBreakpointLocation_GetCondition", _wrap_SBBreakpointLocation_GetCondition, METH_O, "\n"
		"SBBreakpointLocation_GetCondition(SBBreakpointLocation self) -> char const *\n"
		"\n"
		"    Get the condition expression for the breakpoint location.\n"
		""},
	 { "SBBreakpointLocation_SetAutoContinue", _wrap_SBBreakpointLocation_SetAutoContinue, METH_VARARGS, "SBBreakpointLocation_SetAutoContinue(SBBreakpointLocation self, bool auto_continue)"},
	 { "SBBreakpointLocation_GetAutoContinue", _wrap_SBBreakpointLocation_GetAutoContinue, METH_O, "SBBreakpointLocation_GetAutoContinue(SBBreakpointLocation self) -> bool"},
	 { "SBBreakpointLocation_SetScriptCallbackFunction", _wrap_SBBreakpointLocation_SetScriptCallbackFunction, METH_VARARGS, "\n"
		"SBBreakpointLocation_SetScriptCallbackFunction(SBBreakpointLocation self, char const * callback_function_name)\n"
		"SBBreakpointLocation_SetScriptCallbackFunction(SBBreakpointLocation self, char const * callback_function_name, SBStructuredData extra_args) -> SBError\n"
		"\n"
		"    Set the name of the script function to be called when the breakpoint is hit.\n"
		"    To use this variant, the function should take (frame, bp_loc, extra_args, internal_dict) and\n"
		"    when the breakpoint is hit the extra_args will be passed to the callback function.\n"
		""},
	 { "SBBreakpointLocation_SetScriptCallbackBody", _wrap_SBBreakpointLocation_SetScriptCallbackBody, METH_VARARGS, "\n"
		"SBBreakpointLocation_SetScriptCallbackBody(SBBreakpointLocation self, char const * script_body_text) -> SBError\n"
		"\n"
		"    Provide the body for the script function to be called when the breakpoint location is hit.\n"
		"    The body will be wrapped in a function, which be passed two arguments:\n"
		"    'frame' - which holds the bottom-most SBFrame of the thread that hit the breakpoint\n"
		"    'bpno'  - which is the SBBreakpointLocation to which the callback was attached.\n"
		"\n"
		"    The error parameter is currently ignored, but will at some point hold the Python\n"
		"    compilation diagnostics.\n"
		"    Returns true if the body compiles successfully, false if not.\n"
		""},
	 { "SBBreakpointLocation_SetCommandLineCommands", _wrap_SBBreakpointLocation_SetCommandLineCommands, METH_VARARGS, "SBBreakpointLocation_SetCommandLineCommands(SBBreakpointLocation self, SBStringList commands)"},
	 { "SBBreakpointLocation_GetCommandLineCommands", _wrap_SBBreakpointLocation_GetCommandLineCommands, METH_VARARGS, "SBBreakpointLocation_GetCommandLineCommands(SBBreakpointLocation self, SBStringList commands) -> bool"},
	 { "SBBreakpointLocation_SetThreadID", _wrap_SBBreakpointLocation_SetThreadID, METH_VARARGS, "SBBreakpointLocation_SetThreadID(SBBreakpointLocation self, lldb::tid_t sb_thread_id)"},
	 { "SBBreakpointLocation_GetThreadID", _wrap_SBBreakpointLocation_GetThreadID, METH_O, "SBBreakpointLocation_GetThreadID(SBBreakpointLocation self) -> lldb::tid_t"},
	 { "SBBreakpointLocation_SetThreadIndex", _wrap_SBBreakpointLocation_SetThreadIndex, METH_VARARGS, "SBBreakpointLocation_SetThreadIndex(SBBreakpointLocation self, uint32_t index)"},
	 { "SBBreakpointLocation_GetThreadIndex", _wrap_SBBreakpointLocation_GetThreadIndex, METH_O, "SBBreakpointLocation_GetThreadIndex(SBBreakpointLocation self) -> uint32_t"},
	 { "SBBreakpointLocation_SetThreadName", _wrap_SBBreakpointLocation_SetThreadName, METH_VARARGS, "SBBreakpointLocation_SetThreadName(SBBreakpointLocation self, char const * thread_name)"},
	 { "SBBreakpointLocation_GetThreadName", _wrap_SBBreakpointLocation_GetThreadName, METH_O, "SBBreakpointLocation_GetThreadName(SBBreakpointLocation self) -> char const *"},
	 { "SBBreakpointLocation_SetQueueName", _wrap_SBBreakpointLocation_SetQueueName, METH_VARARGS, "SBBreakpointLocation_SetQueueName(SBBreakpointLocation self, char const * queue_name)"},
	 { "SBBreakpointLocation_GetQueueName", _wrap_SBBreakpointLocation_GetQueueName, METH_O, "SBBreakpointLocation_GetQueueName(SBBreakpointLocation self) -> char const *"},
	 { "SBBreakpointLocation_IsResolved", _wrap_SBBreakpointLocation_IsResolved, METH_O, "SBBreakpointLocation_IsResolved(SBBreakpointLocation self) -> bool"},
	 { "SBBreakpointLocation_GetDescription", _wrap_SBBreakpointLocation_GetDescription, METH_VARARGS, "SBBreakpointLocation_GetDescription(SBBreakpointLocation self, SBStream description, lldb::DescriptionLevel level) -> bool"},
	 { "SBBreakpointLocation_GetBreakpoint", _wrap_SBBreakpointLocation_GetBreakpoint, METH_O, "SBBreakpointLocation_GetBreakpoint(SBBreakpointLocation self) -> SBBreakpoint"},
	 { "SBBreakpointLocation___repr__", _wrap_SBBreakpointLocation___repr__, METH_O, "SBBreakpointLocation___repr__(SBBreakpointLocation self) -> std::string"},
	 { "SBBreakpointLocation_swigregister", SBBreakpointLocation_swigregister, METH_O, NULL},
	 { "SBBreakpointLocation_swiginit", SBBreakpointLocation_swiginit, METH_VARARGS, NULL},
	 { "new_SBBreakpointName", _wrap_new_SBBreakpointName, METH_VARARGS, "\n"
		"SBBreakpointName()\n"
		"SBBreakpointName(SBTarget target, char const * name)\n"
		"SBBreakpointName(SBBreakpoint bkpt, char const * name)\n"
		"new_SBBreakpointName(SBBreakpointName rhs) -> SBBreakpointName\n"
		""},
	 { "delete_SBBreakpointName", _wrap_delete_SBBreakpointName, METH_O, "delete_SBBreakpointName(SBBreakpointName self)"},
	 { "SBBreakpointName___eq__", _wrap_SBBreakpointName___eq__, METH_VARARGS, "SBBreakpointName___eq__(SBBreakpointName self, SBBreakpointName rhs) -> bool"},
	 { "SBBreakpointName___ne__", _wrap_SBBreakpointName___ne__, METH_VARARGS, "SBBreakpointName___ne__(SBBreakpointName self, SBBreakpointName rhs) -> bool"},
	 { "SBBreakpointName___nonzero__", _wrap_SBBreakpointName___nonzero__, METH_O, "SBBreakpointName___nonzero__(SBBreakpointName self) -> bool"},
	 { "SBBreakpointName_IsValid", _wrap_SBBreakpointName_IsValid, METH_O, "SBBreakpointName_IsValid(SBBreakpointName self) -> bool"},
	 { "SBBreakpointName_GetName", _wrap_SBBreakpointName_GetName, METH_O, "SBBreakpointName_GetName(SBBreakpointName self) -> char const *"},
	 { "SBBreakpointName_SetEnabled", _wrap_SBBreakpointName_SetEnabled, METH_VARARGS, "SBBreakpointName_SetEnabled(SBBreakpointName self, bool enable)"},
	 { "SBBreakpointName_IsEnabled", _wrap_SBBreakpointName_IsEnabled, METH_O, "SBBreakpointName_IsEnabled(SBBreakpointName self) -> bool"},
	 { "SBBreakpointName_SetOneShot", _wrap_SBBreakpointName_SetOneShot, METH_VARARGS, "SBBreakpointName_SetOneShot(SBBreakpointName self, bool one_shot)"},
	 { "SBBreakpointName_IsOneShot", _wrap_SBBreakpointName_IsOneShot, METH_O, "SBBreakpointName_IsOneShot(SBBreakpointName self) -> bool"},
	 { "SBBreakpointName_SetIgnoreCount", _wrap_SBBreakpointName_SetIgnoreCount, METH_VARARGS, "SBBreakpointName_SetIgnoreCount(SBBreakpointName self, uint32_t count)"},
	 { "SBBreakpointName_GetIgnoreCount", _wrap_SBBreakpointName_GetIgnoreCount, METH_O, "SBBreakpointName_GetIgnoreCount(SBBreakpointName self) -> uint32_t"},
	 { "SBBreakpointName_SetCondition", _wrap_SBBreakpointName_SetCondition, METH_VARARGS, "SBBreakpointName_SetCondition(SBBreakpointName self, char const * condition)"},
	 { "SBBreakpointName_GetCondition", _wrap_SBBreakpointName_GetCondition, METH_O, "SBBreakpointName_GetCondition(SBBreakpointName self) -> char const *"},
	 { "SBBreakpointName_SetAutoContinue", _wrap_SBBreakpointName_SetAutoContinue, METH_VARARGS, "SBBreakpointName_SetAutoContinue(SBBreakpointName self, bool auto_continue)"},
	 { "SBBreakpointName_GetAutoContinue", _wrap_SBBreakpointName_GetAutoContinue, METH_O, "SBBreakpointName_GetAutoContinue(SBBreakpointName self) -> bool"},
	 { "SBBreakpointName_SetThreadID", _wrap_SBBreakpointName_SetThreadID, METH_VARARGS, "SBBreakpointName_SetThreadID(SBBreakpointName self, lldb::tid_t sb_thread_id)"},
	 { "SBBreakpointName_GetThreadID", _wrap_SBBreakpointName_GetThreadID, METH_O, "SBBreakpointName_GetThreadID(SBBreakpointName self) -> lldb::tid_t"},
	 { "SBBreakpointName_SetThreadIndex", _wrap_SBBreakpointName_SetThreadIndex, METH_VARARGS, "SBBreakpointName_SetThreadIndex(SBBreakpointName self, uint32_t index)"},
	 { "SBBreakpointName_GetThreadIndex", _wrap_SBBreakpointName_GetThreadIndex, METH_O, "SBBreakpointName_GetThreadIndex(SBBreakpointName self) -> uint32_t"},
	 { "SBBreakpointName_SetThreadName", _wrap_SBBreakpointName_SetThreadName, METH_VARARGS, "SBBreakpointName_SetThreadName(SBBreakpointName self, char const * thread_name)"},
	 { "SBBreakpointName_GetThreadName", _wrap_SBBreakpointName_GetThreadName, METH_O, "SBBreakpointName_GetThreadName(SBBreakpointName self) -> char const *"},
	 { "SBBreakpointName_SetQueueName", _wrap_SBBreakpointName_SetQueueName, METH_VARARGS, "SBBreakpointName_SetQueueName(SBBreakpointName self, char const * queue_name)"},
	 { "SBBreakpointName_GetQueueName", _wrap_SBBreakpointName_GetQueueName, METH_O, "SBBreakpointName_GetQueueName(SBBreakpointName self) -> char const *"},
	 { "SBBreakpointName_SetScriptCallbackFunction", _wrap_SBBreakpointName_SetScriptCallbackFunction, METH_VARARGS, "\n"
		"SBBreakpointName_SetScriptCallbackFunction(SBBreakpointName self, char const * callback_function_name)\n"
		"SBBreakpointName_SetScriptCallbackFunction(SBBreakpointName self, char const * callback_function_name, SBStructuredData extra_args) -> SBError\n"
		""},
	 { "SBBreakpointName_SetCommandLineCommands", _wrap_SBBreakpointName_SetCommandLineCommands, METH_VARARGS, "SBBreakpointName_SetCommandLineCommands(SBBreakpointName self, SBStringList commands)"},
	 { "SBBreakpointName_GetCommandLineCommands", _wrap_SBBreakpointName_GetCommandLineCommands, METH_VARARGS, "SBBreakpointName_GetCommandLineCommands(SBBreakpointName self, SBStringList commands) -> bool"},
	 { "SBBreakpointName_SetScriptCallbackBody", _wrap_SBBreakpointName_SetScriptCallbackBody, METH_VARARGS, "SBBreakpointName_SetScriptCallbackBody(SBBreakpointName self, char const * script_body_text) -> SBError"},
	 { "SBBreakpointName_GetHelpString", _wrap_SBBreakpointName_GetHelpString, METH_O, "SBBreakpointName_GetHelpString(SBBreakpointName self) -> char const *"},
	 { "SBBreakpointName_SetHelpString", _wrap_SBBreakpointName_SetHelpString, METH_VARARGS, "SBBreakpointName_SetHelpString(SBBreakpointName self, char const * help_string)"},
	 { "SBBreakpointName_GetAllowList", _wrap_SBBreakpointName_GetAllowList, METH_O, "SBBreakpointName_GetAllowList(SBBreakpointName self) -> bool"},
	 { "SBBreakpointName_SetAllowList", _wrap_SBBreakpointName_SetAllowList, METH_VARARGS, "SBBreakpointName_SetAllowList(SBBreakpointName self, bool value)"},
	 { "SBBreakpointName_GetAllowDelete", _wrap_SBBreakpointName_GetAllowDelete, METH_O, "SBBreakpointName_GetAllowDelete(SBBreakpointName self) -> bool"},
	 { "SBBreakpointName_SetAllowDelete", _wrap_SBBreakpointName_SetAllowDelete, METH_VARARGS, "SBBreakpointName_SetAllowDelete(SBBreakpointName self, bool value)"},
	 { "SBBreakpointName_GetAllowDisable", _wrap_SBBreakpointName_GetAllowDisable, METH_O, "SBBreakpointName_GetAllowDisable(SBBreakpointName self) -> bool"},
	 { "SBBreakpointName_SetAllowDisable", _wrap_SBBreakpointName_SetAllowDisable, METH_VARARGS, "SBBreakpointName_SetAllowDisable(SBBreakpointName self, bool value)"},
	 { "SBBreakpointName_GetDescription", _wrap_SBBreakpointName_GetDescription, METH_VARARGS, "SBBreakpointName_GetDescription(SBBreakpointName self, SBStream description) -> bool"},
	 { "SBBreakpointName___repr__", _wrap_SBBreakpointName___repr__, METH_O, "SBBreakpointName___repr__(SBBreakpointName self) -> std::string"},
	 { "SBBreakpointName_swigregister", SBBreakpointName_swigregister, METH_O, NULL},
	 { "SBBreakpointName_swiginit", SBBreakpointName_swiginit, METH_VARARGS, NULL},
	 { "new_SBBroadcaster", _wrap_new_SBBroadcaster, METH_VARARGS, "\n"
		"SBBroadcaster()\n"
		"SBBroadcaster(char const * name)\n"
		"new_SBBroadcaster(SBBroadcaster rhs) -> SBBroadcaster\n"
		""},
	 { "delete_SBBroadcaster", _wrap_delete_SBBroadcaster, METH_O, "delete_SBBroadcaster(SBBroadcaster self)"},
	 { "SBBroadcaster___nonzero__", _wrap_SBBroadcaster___nonzero__, METH_O, "SBBroadcaster___nonzero__(SBBroadcaster self) -> bool"},
	 { "SBBroadcaster_IsValid", _wrap_SBBroadcaster_IsValid, METH_O, "SBBroadcaster_IsValid(SBBroadcaster self) -> bool"},
	 { "SBBroadcaster_Clear", _wrap_SBBroadcaster_Clear, METH_O, "SBBroadcaster_Clear(SBBroadcaster self)"},
	 { "SBBroadcaster_BroadcastEventByType", _wrap_SBBroadcaster_BroadcastEventByType, METH_VARARGS, "SBBroadcaster_BroadcastEventByType(SBBroadcaster self, uint32_t event_type, bool unique=False)"},
	 { "SBBroadcaster_BroadcastEvent", _wrap_SBBroadcaster_BroadcastEvent, METH_VARARGS, "SBBroadcaster_BroadcastEvent(SBBroadcaster self, SBEvent event, bool unique=False)"},
	 { "SBBroadcaster_AddInitialEventsToListener", _wrap_SBBroadcaster_AddInitialEventsToListener, METH_VARARGS, "SBBroadcaster_AddInitialEventsToListener(SBBroadcaster self, SBListener listener, uint32_t requested_events)"},
	 { "SBBroadcaster_AddListener", _wrap_SBBroadcaster_AddListener, METH_VARARGS, "SBBroadcaster_AddListener(SBBroadcaster self, SBListener listener, uint32_t event_mask) -> uint32_t"},
	 { "SBBroadcaster_GetName", _wrap_SBBroadcaster_GetName, METH_O, "SBBroadcaster_GetName(SBBroadcaster self) -> char const *"},
	 { "SBBroadcaster_EventTypeHasListeners", _wrap_SBBroadcaster_EventTypeHasListeners, METH_VARARGS, "SBBroadcaster_EventTypeHasListeners(SBBroadcaster self, uint32_t event_type) -> bool"},
	 { "SBBroadcaster_RemoveListener", _wrap_SBBroadcaster_RemoveListener, METH_VARARGS, "SBBroadcaster_RemoveListener(SBBroadcaster self, SBListener listener, uint32_t event_mask=4294967295U) -> bool"},
	 { "SBBroadcaster___eq__", _wrap_SBBroadcaster___eq__, METH_VARARGS, "SBBroadcaster___eq__(SBBroadcaster self, SBBroadcaster rhs) -> bool"},
	 { "SBBroadcaster___ne__", _wrap_SBBroadcaster___ne__, METH_VARARGS, "SBBroadcaster___ne__(SBBroadcaster self, SBBroadcaster rhs) -> bool"},
	 { "SBBroadcaster___lt__", _wrap_SBBroadcaster___lt__, METH_VARARGS, "SBBroadcaster___lt__(SBBroadcaster self, SBBroadcaster rhs) -> bool"},
	 { "SBBroadcaster_swigregister", SBBroadcaster_swigregister, METH_O, NULL},
	 { "SBBroadcaster_swiginit", SBBroadcaster_swiginit, METH_VARARGS, NULL},
	 { "new_SBCommandInterpreter", _wrap_new_SBCommandInterpreter, METH_VARARGS, "\n"
		"SBCommandInterpreter()\n"
		"new_SBCommandInterpreter(SBCommandInterpreter rhs) -> SBCommandInterpreter\n"
		""},
	 { "delete_SBCommandInterpreter", _wrap_delete_SBCommandInterpreter, METH_O, "delete_SBCommandInterpreter(SBCommandInterpreter self)"},
	 { "SBCommandInterpreter_GetArgumentTypeAsCString", _wrap_SBCommandInterpreter_GetArgumentTypeAsCString, METH_O, "SBCommandInterpreter_GetArgumentTypeAsCString(lldb::CommandArgumentType const arg_type) -> char const *"},
	 { "SBCommandInterpreter_GetArgumentDescriptionAsCString", _wrap_SBCommandInterpreter_GetArgumentDescriptionAsCString, METH_O, "SBCommandInterpreter_GetArgumentDescriptionAsCString(lldb::CommandArgumentType const arg_type) -> char const *"},
	 { "SBCommandInterpreter_EventIsCommandInterpreterEvent", _wrap_SBCommandInterpreter_EventIsCommandInterpreterEvent, METH_O, "SBCommandInterpreter_EventIsCommandInterpreterEvent(SBEvent event) -> bool"},
	 { "SBCommandInterpreter___nonzero__", _wrap_SBCommandInterpreter___nonzero__, METH_O, "SBCommandInterpreter___nonzero__(SBCommandInterpreter self) -> bool"},
	 { "SBCommandInterpreter_IsValid", _wrap_SBCommandInterpreter_IsValid, METH_O, "SBCommandInterpreter_IsValid(SBCommandInterpreter self) -> bool"},
	 { "SBCommandInterpreter_CommandExists", _wrap_SBCommandInterpreter_CommandExists, METH_VARARGS, "\n"
		"Return whether a built-in command with the passed in\n"
		"name or command path exists.\n"
		"\n"
		":type cmd: string, in\n"
		":param cmd:\n"
		"      The command or command path to search for.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"      **true** if the command exists, **false** otherwise.\n"
		""},
	 { "SBCommandInterpreter_UserCommandExists", _wrap_SBCommandInterpreter_UserCommandExists, METH_VARARGS, "\n"
		"Return whether a user defined command with the passed in\n"
		"name or command path exists.\n"
		"\n"
		":type cmd: string, in\n"
		":param cmd:\n"
		"      The command or command path to search for.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"      **true** if the command exists, **false** otherwise.\n"
		""},
	 { "SBCommandInterpreter_AliasExists", _wrap_SBCommandInterpreter_AliasExists, METH_VARARGS, "\n"
		"Return whether the passed in name or command path\n"
		"exists and is an alias to some other command.\n"
		"\n"
		":type cmd: string, in\n"
		":param cmd:\n"
		"      The command or command path to search for.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"      **true** if the command exists, **false** otherwise.\n"
		""},
	 { "SBCommandInterpreter_GetBroadcaster", _wrap_SBCommandInterpreter_GetBroadcaster, METH_O, "SBCommandInterpreter_GetBroadcaster(SBCommandInterpreter self) -> SBBroadcaster"},
	 { "SBCommandInterpreter_GetBroadcasterClass", _wrap_SBCommandInterpreter_GetBroadcasterClass, METH_NOARGS, "SBCommandInterpreter_GetBroadcasterClass() -> char const *"},
	 { "SBCommandInterpreter_HasCommands", _wrap_SBCommandInterpreter_HasCommands, METH_O, "SBCommandInterpreter_HasCommands(SBCommandInterpreter self) -> bool"},
	 { "SBCommandInterpreter_HasAliases", _wrap_SBCommandInterpreter_HasAliases, METH_O, "SBCommandInterpreter_HasAliases(SBCommandInterpreter self) -> bool"},
	 { "SBCommandInterpreter_HasAliasOptions", _wrap_SBCommandInterpreter_HasAliasOptions, METH_O, "SBCommandInterpreter_HasAliasOptions(SBCommandInterpreter self) -> bool"},
	 { "SBCommandInterpreter_IsInteractive", _wrap_SBCommandInterpreter_IsInteractive, METH_O, "SBCommandInterpreter_IsInteractive(SBCommandInterpreter self) -> bool"},
	 { "SBCommandInterpreter_GetProcess", _wrap_SBCommandInterpreter_GetProcess, METH_O, "SBCommandInterpreter_GetProcess(SBCommandInterpreter self) -> SBProcess"},
	 { "SBCommandInterpreter_GetDebugger", _wrap_SBCommandInterpreter_GetDebugger, METH_O, "SBCommandInterpreter_GetDebugger(SBCommandInterpreter self) -> SBDebugger"},
	 { "SBCommandInterpreter_SourceInitFileInHomeDirectory", _wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory, METH_VARARGS, "\n"
		"SBCommandInterpreter_SourceInitFileInHomeDirectory(SBCommandInterpreter self, SBCommandReturnObject result)\n"
		"SBCommandInterpreter_SourceInitFileInHomeDirectory(SBCommandInterpreter self, SBCommandReturnObject result, bool is_repl)\n"
		""},
	 { "SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory", _wrap_SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory, METH_VARARGS, "SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory(SBCommandInterpreter self, SBCommandReturnObject result)"},
	 { "SBCommandInterpreter_HandleCommand", _wrap_SBCommandInterpreter_HandleCommand, METH_VARARGS, "\n"
		"SBCommandInterpreter_HandleCommand(SBCommandInterpreter self, char const * command_line, SBCommandReturnObject result, bool add_to_history=False) -> lldb::ReturnStatus\n"
		"SBCommandInterpreter_HandleCommand(SBCommandInterpreter self, char const * command_line, SBExecutionContext exe_ctx, SBCommandReturnObject result, bool add_to_history=False) -> lldb::ReturnStatus\n"
		""},
	 { "SBCommandInterpreter_HandleCommandsFromFile", _wrap_SBCommandInterpreter_HandleCommandsFromFile, METH_VARARGS, "SBCommandInterpreter_HandleCommandsFromFile(SBCommandInterpreter self, SBFileSpec file, SBExecutionContext override_context, SBCommandInterpreterRunOptions options, SBCommandReturnObject result)"},
	 { "SBCommandInterpreter_HandleCompletion", _wrap_SBCommandInterpreter_HandleCompletion, METH_VARARGS, "SBCommandInterpreter_HandleCompletion(SBCommandInterpreter self, char const * current_line, uint32_t cursor_pos, int match_start_point, int max_return_elements, SBStringList matches) -> int"},
	 { "SBCommandInterpreter_HandleCompletionWithDescriptions", _wrap_SBCommandInterpreter_HandleCompletionWithDescriptions, METH_VARARGS, "SBCommandInterpreter_HandleCompletionWithDescriptions(SBCommandInterpreter self, char const * current_line, uint32_t cursor_pos, int match_start_point, int max_return_elements, SBStringList matches, SBStringList descriptions) -> int"},
	 { "SBCommandInterpreter_WasInterrupted", _wrap_SBCommandInterpreter_WasInterrupted, METH_O, "\n"
		"Returns whether an interrupt flag was raised either by the SBDebugger -\n"
		"when the function is not running on the RunCommandInterpreter thread, or\n"
		"by SBCommandInterpreter::InterruptCommand if it is.  If your code is doing\n"
		"interruptible work, check this API periodically, and interrupt if it\n"
		"returns true.\n"
		""},
	 { "SBCommandInterpreter_InterruptCommand", _wrap_SBCommandInterpreter_InterruptCommand, METH_O, "\n"
		"Interrupts the command currently executing in the RunCommandInterpreter\n"
		"thread.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"      **true** if there was a command in progress to recieve the interrupt.\n"
		"      **false** if there's no command currently in flight.\n"
		""},
	 { "SBCommandInterpreter_SetCommandOverrideCallback", _wrap_SBCommandInterpreter_SetCommandOverrideCallback, METH_VARARGS, "SBCommandInterpreter_SetCommandOverrideCallback(SBCommandInterpreter self, char const * command_name, lldb::CommandOverrideCallback callback) -> bool"},
	 { "SBCommandInterpreter_IsActive", _wrap_SBCommandInterpreter_IsActive, METH_O, "\n"
		"Return true if the command interpreter is the active IO handler.\n"
		"\n"
		"This indicates that any input coming into the debugger handles will\n"
		"go to the command interpreter and will result in LLDB command line\n"
		"commands being executed.\n"
		""},
	 { "SBCommandInterpreter_GetIOHandlerControlSequence", _wrap_SBCommandInterpreter_GetIOHandlerControlSequence, METH_VARARGS, "\n"
		"Get the string that needs to be written to the debugger stdin file\n"
		"handle when a control character is typed.\n"
		"\n"
		"Some GUI programs will intercept \"control + char\" sequences and want\n"
		"to have them do what normally would happen when using a real\n"
		"terminal, so this function allows GUI programs to emulate this\n"
		"functionality.\n"
		"\n"
		":type ch: char, in\n"
		":param ch:\n"
		"        The character that was typed along with the control key\n"
		"\n"
		":rtype: string\n"
		":return: \n"
		"        The string that should be written into the file handle that is\n"
		"        feeding the input stream for the debugger, or nullptr if there is\n"
		"        no string for this control key.\n"
		""},
	 { "SBCommandInterpreter_GetPromptOnQuit", _wrap_SBCommandInterpreter_GetPromptOnQuit, METH_O, "SBCommandInterpreter_GetPromptOnQuit(SBCommandInterpreter self) -> bool"},
	 { "SBCommandInterpreter_SetPromptOnQuit", _wrap_SBCommandInterpreter_SetPromptOnQuit, METH_VARARGS, "SBCommandInterpreter_SetPromptOnQuit(SBCommandInterpreter self, bool b)"},
	 { "SBCommandInterpreter_AllowExitCodeOnQuit", _wrap_SBCommandInterpreter_AllowExitCodeOnQuit, METH_VARARGS, "\n"
		"Sets whether the command interpreter should allow custom exit codes\n"
		"for the 'quit' command.\n"
		""},
	 { "SBCommandInterpreter_HasCustomQuitExitCode", _wrap_SBCommandInterpreter_HasCustomQuitExitCode, METH_O, "\n"
		"Returns true if the user has called the 'quit' command with a custom exit\n"
		"code.\n"
		""},
	 { "SBCommandInterpreter_GetQuitStatus", _wrap_SBCommandInterpreter_GetQuitStatus, METH_O, "\n"
		"Returns the exit code that the user has specified when running the\n"
		"'quit' command. Returns 0 if the user hasn't called 'quit' at all or\n"
		"without a custom exit code.\n"
		""},
	 { "SBCommandInterpreter_ResolveCommand", _wrap_SBCommandInterpreter_ResolveCommand, METH_VARARGS, "\n"
		"Resolve the command just as HandleCommand would, expanding abbreviations\n"
		"and aliases.  If successful, result->GetOutput has the full expansion.\n"
		""},
	 { "SBCommandInterpreter_GetStatistics", _wrap_SBCommandInterpreter_GetStatistics, METH_O, "SBCommandInterpreter_GetStatistics(SBCommandInterpreter self) -> SBStructuredData"},
	 { "SBCommandInterpreter_GetTranscript", _wrap_SBCommandInterpreter_GetTranscript, METH_O, "\n"
		"Returns a list of handled commands, output and error. Each element in\n"
		"the list is a dictionary with the following keys/values:\n"
		"- \"command\" (string): The command that was given by the user.\n"
		"- \"commandName\" (string): The name of the executed command.\n"
		"- \"commandArguments\" (string): The arguments of the executed command.\n"
		"- \"output\" (string): The output of the command. Empty (\"\") if no output.\n"
		"- \"error\" (string): The error of the command. Empty (\"\") if no error.\n"
		"- \"durationInSeconds\" (float): The time it took to execute the command.\n"
		"- \"timestampInEpochSeconds\" (int): The timestamp when the command is\n"
		"  executed.\n"
		"\n"
		"Turn on settings `interpreter.save-transcript` for LLDB to populate\n"
		"this list. Otherwise this list is empty.\n"
		""},
	 { "SBCommandInterpreter_SetPrintCallback", _wrap_SBCommandInterpreter_SetPrintCallback, METH_VARARGS, "SBCommandInterpreter_SetPrintCallback(SBCommandInterpreter self, lldb::SBCommandPrintCallback callback)"},
	 { "SBCommandInterpreter_swigregister", SBCommandInterpreter_swigregister, METH_O, NULL},
	 { "SBCommandInterpreter_swiginit", SBCommandInterpreter_swiginit, METH_VARARGS, NULL},
	 { "new_SBCommandInterpreterRunOptions", _wrap_new_SBCommandInterpreterRunOptions, METH_VARARGS, "\n"
		"SBCommandInterpreterRunOptions()\n"
		"new_SBCommandInterpreterRunOptions(SBCommandInterpreterRunOptions rhs) -> SBCommandInterpreterRunOptions\n"
		""},
	 { "delete_SBCommandInterpreterRunOptions", _wrap_delete_SBCommandInterpreterRunOptions, METH_O, "delete_SBCommandInterpreterRunOptions(SBCommandInterpreterRunOptions self)"},
	 { "SBCommandInterpreterRunOptions_GetStopOnContinue", _wrap_SBCommandInterpreterRunOptions_GetStopOnContinue, METH_O, "SBCommandInterpreterRunOptions_GetStopOnContinue(SBCommandInterpreterRunOptions self) -> bool"},
	 { "SBCommandInterpreterRunOptions_SetStopOnContinue", _wrap_SBCommandInterpreterRunOptions_SetStopOnContinue, METH_VARARGS, "SBCommandInterpreterRunOptions_SetStopOnContinue(SBCommandInterpreterRunOptions self, bool arg2)"},
	 { "SBCommandInterpreterRunOptions_GetStopOnError", _wrap_SBCommandInterpreterRunOptions_GetStopOnError, METH_O, "SBCommandInterpreterRunOptions_GetStopOnError(SBCommandInterpreterRunOptions self) -> bool"},
	 { "SBCommandInterpreterRunOptions_SetStopOnError", _wrap_SBCommandInterpreterRunOptions_SetStopOnError, METH_VARARGS, "SBCommandInterpreterRunOptions_SetStopOnError(SBCommandInterpreterRunOptions self, bool arg2)"},
	 { "SBCommandInterpreterRunOptions_GetStopOnCrash", _wrap_SBCommandInterpreterRunOptions_GetStopOnCrash, METH_O, "SBCommandInterpreterRunOptions_GetStopOnCrash(SBCommandInterpreterRunOptions self) -> bool"},
	 { "SBCommandInterpreterRunOptions_SetStopOnCrash", _wrap_SBCommandInterpreterRunOptions_SetStopOnCrash, METH_VARARGS, "SBCommandInterpreterRunOptions_SetStopOnCrash(SBCommandInterpreterRunOptions self, bool arg2)"},
	 { "SBCommandInterpreterRunOptions_GetEchoCommands", _wrap_SBCommandInterpreterRunOptions_GetEchoCommands, METH_O, "SBCommandInterpreterRunOptions_GetEchoCommands(SBCommandInterpreterRunOptions self) -> bool"},
	 { "SBCommandInterpreterRunOptions_SetEchoCommands", _wrap_SBCommandInterpreterRunOptions_SetEchoCommands, METH_VARARGS, "SBCommandInterpreterRunOptions_SetEchoCommands(SBCommandInterpreterRunOptions self, bool arg2)"},
	 { "SBCommandInterpreterRunOptions_GetEchoCommentCommands", _wrap_SBCommandInterpreterRunOptions_GetEchoCommentCommands, METH_O, "SBCommandInterpreterRunOptions_GetEchoCommentCommands(SBCommandInterpreterRunOptions self) -> bool"},
	 { "SBCommandInterpreterRunOptions_SetEchoCommentCommands", _wrap_SBCommandInterpreterRunOptions_SetEchoCommentCommands, METH_VARARGS, "SBCommandInterpreterRunOptions_SetEchoCommentCommands(SBCommandInterpreterRunOptions self, bool echo)"},
	 { "SBCommandInterpreterRunOptions_GetPrintResults", _wrap_SBCommandInterpreterRunOptions_GetPrintResults, METH_O, "SBCommandInterpreterRunOptions_GetPrintResults(SBCommandInterpreterRunOptions self) -> bool"},
	 { "SBCommandInterpreterRunOptions_SetPrintResults", _wrap_SBCommandInterpreterRunOptions_SetPrintResults, METH_VARARGS, "SBCommandInterpreterRunOptions_SetPrintResults(SBCommandInterpreterRunOptions self, bool arg2)"},
	 { "SBCommandInterpreterRunOptions_GetPrintErrors", _wrap_SBCommandInterpreterRunOptions_GetPrintErrors, METH_O, "SBCommandInterpreterRunOptions_GetPrintErrors(SBCommandInterpreterRunOptions self) -> bool"},
	 { "SBCommandInterpreterRunOptions_SetPrintErrors", _wrap_SBCommandInterpreterRunOptions_SetPrintErrors, METH_VARARGS, "SBCommandInterpreterRunOptions_SetPrintErrors(SBCommandInterpreterRunOptions self, bool arg2)"},
	 { "SBCommandInterpreterRunOptions_GetAddToHistory", _wrap_SBCommandInterpreterRunOptions_GetAddToHistory, METH_O, "SBCommandInterpreterRunOptions_GetAddToHistory(SBCommandInterpreterRunOptions self) -> bool"},
	 { "SBCommandInterpreterRunOptions_SetAddToHistory", _wrap_SBCommandInterpreterRunOptions_SetAddToHistory, METH_VARARGS, "SBCommandInterpreterRunOptions_SetAddToHistory(SBCommandInterpreterRunOptions self, bool arg2)"},
	 { "SBCommandInterpreterRunOptions_GetAutoHandleEvents", _wrap_SBCommandInterpreterRunOptions_GetAutoHandleEvents, METH_O, "SBCommandInterpreterRunOptions_GetAutoHandleEvents(SBCommandInterpreterRunOptions self) -> bool"},
	 { "SBCommandInterpreterRunOptions_SetAutoHandleEvents", _wrap_SBCommandInterpreterRunOptions_SetAutoHandleEvents, METH_VARARGS, "SBCommandInterpreterRunOptions_SetAutoHandleEvents(SBCommandInterpreterRunOptions self, bool arg2)"},
	 { "SBCommandInterpreterRunOptions_GetSpawnThread", _wrap_SBCommandInterpreterRunOptions_GetSpawnThread, METH_O, "SBCommandInterpreterRunOptions_GetSpawnThread(SBCommandInterpreterRunOptions self) -> bool"},
	 { "SBCommandInterpreterRunOptions_SetSpawnThread", _wrap_SBCommandInterpreterRunOptions_SetSpawnThread, METH_VARARGS, "SBCommandInterpreterRunOptions_SetSpawnThread(SBCommandInterpreterRunOptions self, bool arg2)"},
	 { "SBCommandInterpreterRunOptions_GetAllowRepeats", _wrap_SBCommandInterpreterRunOptions_GetAllowRepeats, METH_O, "SBCommandInterpreterRunOptions_GetAllowRepeats(SBCommandInterpreterRunOptions self) -> bool"},
	 { "SBCommandInterpreterRunOptions_SetAllowRepeats", _wrap_SBCommandInterpreterRunOptions_SetAllowRepeats, METH_VARARGS, "\n"
		"By default, RunCommandInterpreter will discard repeats if the\n"
		"IOHandler being used is not interactive.  Setting AllowRepeats to true\n"
		"will override this behavior and always process empty lines in the input\n"
		"as a repeat command.\n"
		""},
	 { "SBCommandInterpreterRunOptions_swigregister", SBCommandInterpreterRunOptions_swigregister, METH_O, NULL},
	 { "SBCommandInterpreterRunOptions_swiginit", SBCommandInterpreterRunOptions_swiginit, METH_VARARGS, NULL},
	 { "new_SBCommandReturnObject", _wrap_new_SBCommandReturnObject, METH_VARARGS, "\n"
		"SBCommandReturnObject()\n"
		"new_SBCommandReturnObject(SBCommandReturnObject rhs) -> SBCommandReturnObject\n"
		""},
	 { "delete_SBCommandReturnObject", _wrap_delete_SBCommandReturnObject, METH_O, "delete_SBCommandReturnObject(SBCommandReturnObject self)"},
	 { "SBCommandReturnObject___nonzero__", _wrap_SBCommandReturnObject___nonzero__, METH_O, "SBCommandReturnObject___nonzero__(SBCommandReturnObject self) -> bool"},
	 { "SBCommandReturnObject_IsValid", _wrap_SBCommandReturnObject_IsValid, METH_O, "SBCommandReturnObject_IsValid(SBCommandReturnObject self) -> bool"},
	 { "SBCommandReturnObject_GetCommand", _wrap_SBCommandReturnObject_GetCommand, METH_O, "\n"
		"Get the command as the user typed it. Empty string if commands were run on\n"
		"behalf of lldb.\n"
		""},
	 { "SBCommandReturnObject_GetErrorData", _wrap_SBCommandReturnObject_GetErrorData, METH_O, "SBCommandReturnObject_GetErrorData(SBCommandReturnObject self) -> SBStructuredData"},
	 { "SBCommandReturnObject_PutOutput", _wrap_SBCommandReturnObject_PutOutput, METH_VARARGS, "\n"
		"SBCommandReturnObject_PutOutput(SBCommandReturnObject self, SBFile file) -> size_t\n"
		"SBCommandReturnObject_PutOutput(SBCommandReturnObject self, lldb::FileSP BORROWED) -> size_t\n"
		""},
	 { "SBCommandReturnObject_GetOutputSize", _wrap_SBCommandReturnObject_GetOutputSize, METH_O, "SBCommandReturnObject_GetOutputSize(SBCommandReturnObject self) -> size_t"},
	 { "SBCommandReturnObject_GetErrorSize", _wrap_SBCommandReturnObject_GetErrorSize, METH_O, "SBCommandReturnObject_GetErrorSize(SBCommandReturnObject self) -> size_t"},
	 { "SBCommandReturnObject_PutError", _wrap_SBCommandReturnObject_PutError, METH_VARARGS, "\n"
		"SBCommandReturnObject_PutError(SBCommandReturnObject self, SBFile file) -> size_t\n"
		"SBCommandReturnObject_PutError(SBCommandReturnObject self, lldb::FileSP BORROWED) -> size_t\n"
		""},
	 { "SBCommandReturnObject_Clear", _wrap_SBCommandReturnObject_Clear, METH_O, "SBCommandReturnObject_Clear(SBCommandReturnObject self)"},
	 { "SBCommandReturnObject_GetStatus", _wrap_SBCommandReturnObject_GetStatus, METH_O, "SBCommandReturnObject_GetStatus(SBCommandReturnObject self) -> lldb::ReturnStatus"},
	 { "SBCommandReturnObject_SetStatus", _wrap_SBCommandReturnObject_SetStatus, METH_VARARGS, "SBCommandReturnObject_SetStatus(SBCommandReturnObject self, lldb::ReturnStatus status)"},
	 { "SBCommandReturnObject_Succeeded", _wrap_SBCommandReturnObject_Succeeded, METH_O, "SBCommandReturnObject_Succeeded(SBCommandReturnObject self) -> bool"},
	 { "SBCommandReturnObject_HasResult", _wrap_SBCommandReturnObject_HasResult, METH_O, "SBCommandReturnObject_HasResult(SBCommandReturnObject self) -> bool"},
	 { "SBCommandReturnObject_AppendMessage", _wrap_SBCommandReturnObject_AppendMessage, METH_VARARGS, "SBCommandReturnObject_AppendMessage(SBCommandReturnObject self, char const * message)"},
	 { "SBCommandReturnObject_AppendWarning", _wrap_SBCommandReturnObject_AppendWarning, METH_VARARGS, "SBCommandReturnObject_AppendWarning(SBCommandReturnObject self, char const * message)"},
	 { "SBCommandReturnObject_GetDescription", _wrap_SBCommandReturnObject_GetDescription, METH_VARARGS, "SBCommandReturnObject_GetDescription(SBCommandReturnObject self, SBStream description) -> bool"},
	 { "SBCommandReturnObject_PutCString", _wrap_SBCommandReturnObject_PutCString, METH_VARARGS, "SBCommandReturnObject_PutCString(SBCommandReturnObject self, char const * string)"},
	 { "SBCommandReturnObject_GetOutput", _wrap_SBCommandReturnObject_GetOutput, METH_VARARGS, "\n"
		"SBCommandReturnObject_GetOutput(SBCommandReturnObject self) -> char const\n"
		"SBCommandReturnObject_GetOutput(SBCommandReturnObject self, bool only_if_no_immediate) -> char const *\n"
		""},
	 { "SBCommandReturnObject_GetError", _wrap_SBCommandReturnObject_GetError, METH_VARARGS, "\n"
		"SBCommandReturnObject_GetError(SBCommandReturnObject self) -> char const\n"
		"SBCommandReturnObject_GetError(SBCommandReturnObject self, bool only_if_no_immediate) -> char const *\n"
		""},
	 { "SBCommandReturnObject_SetError", _wrap_SBCommandReturnObject_SetError, METH_VARARGS, "\n"
		"SBCommandReturnObject_SetError(SBCommandReturnObject self, SBError error, char const * fallback_error_cstr=None)\n"
		"SBCommandReturnObject_SetError(SBCommandReturnObject self, char const * error_cstr)\n"
		""},
	 { "SBCommandReturnObject_GetValues", _wrap_SBCommandReturnObject_GetValues, METH_VARARGS, "SBCommandReturnObject_GetValues(SBCommandReturnObject self, lldb::DynamicValueType use_dynamic) -> SBValueList"},
	 { "SBCommandReturnObject___repr__", _wrap_SBCommandReturnObject___repr__, METH_O, "SBCommandReturnObject___repr__(SBCommandReturnObject self) -> std::string"},
	 { "SBCommandReturnObject_SetImmediateOutputFile", _wrap_SBCommandReturnObject_SetImmediateOutputFile, METH_VARARGS, "\n"
		"SBCommandReturnObject_SetImmediateOutputFile(SBCommandReturnObject self, SBFile file)\n"
		"SBCommandReturnObject_SetImmediateOutputFile(SBCommandReturnObject self, lldb::FileSP BORROWED)\n"
		"SBCommandReturnObject_SetImmediateOutputFile(SBCommandReturnObject self, lldb::FileSP BORROWED, bool transfer_ownership)\n"
		""},
	 { "SBCommandReturnObject_SetImmediateErrorFile", _wrap_SBCommandReturnObject_SetImmediateErrorFile, METH_VARARGS, "\n"
		"SBCommandReturnObject_SetImmediateErrorFile(SBCommandReturnObject self, SBFile file)\n"
		"SBCommandReturnObject_SetImmediateErrorFile(SBCommandReturnObject self, lldb::FileSP BORROWED)\n"
		"SBCommandReturnObject_SetImmediateErrorFile(SBCommandReturnObject self, lldb::FileSP BORROWED, bool transfer_ownership)\n"
		""},
	 { "SBCommandReturnObject_Print", _wrap_SBCommandReturnObject_Print, METH_VARARGS, "SBCommandReturnObject_Print(SBCommandReturnObject self, char const * str)"},
	 { "SBCommandReturnObject_write", _wrap_SBCommandReturnObject_write, METH_VARARGS, "SBCommandReturnObject_write(SBCommandReturnObject self, char const * str)"},
	 { "SBCommandReturnObject_flush", _wrap_SBCommandReturnObject_flush, METH_O, "SBCommandReturnObject_flush(SBCommandReturnObject self)"},
	 { "SBCommandReturnObject_swigregister", SBCommandReturnObject_swigregister, METH_O, NULL},
	 { "SBCommandReturnObject_swiginit", SBCommandReturnObject_swiginit, METH_VARARGS, NULL},
	 { "new_SBCommunication", _wrap_new_SBCommunication, METH_VARARGS, "\n"
		"SBCommunication()\n"
		"new_SBCommunication(char const * broadcaster_name) -> SBCommunication\n"
		""},
	 { "delete_SBCommunication", _wrap_delete_SBCommunication, METH_O, "delete_SBCommunication(SBCommunication self)"},
	 { "SBCommunication___nonzero__", _wrap_SBCommunication___nonzero__, METH_O, "SBCommunication___nonzero__(SBCommunication self) -> bool"},
	 { "SBCommunication_IsValid", _wrap_SBCommunication_IsValid, METH_O, "SBCommunication_IsValid(SBCommunication self) -> bool"},
	 { "SBCommunication_GetBroadcaster", _wrap_SBCommunication_GetBroadcaster, METH_O, "SBCommunication_GetBroadcaster(SBCommunication self) -> SBBroadcaster"},
	 { "SBCommunication_GetBroadcasterClass", _wrap_SBCommunication_GetBroadcasterClass, METH_NOARGS, "SBCommunication_GetBroadcasterClass() -> char const *"},
	 { "SBCommunication_AdoptFileDesriptor", _wrap_SBCommunication_AdoptFileDesriptor, METH_VARARGS, "SBCommunication_AdoptFileDesriptor(SBCommunication self, int fd, bool owns_fd) -> lldb::ConnectionStatus"},
	 { "SBCommunication_Connect", _wrap_SBCommunication_Connect, METH_VARARGS, "SBCommunication_Connect(SBCommunication self, char const * url) -> lldb::ConnectionStatus"},
	 { "SBCommunication_Disconnect", _wrap_SBCommunication_Disconnect, METH_O, "SBCommunication_Disconnect(SBCommunication self) -> lldb::ConnectionStatus"},
	 { "SBCommunication_IsConnected", _wrap_SBCommunication_IsConnected, METH_O, "SBCommunication_IsConnected(SBCommunication self) -> bool"},
	 { "SBCommunication_GetCloseOnEOF", _wrap_SBCommunication_GetCloseOnEOF, METH_O, "SBCommunication_GetCloseOnEOF(SBCommunication self) -> bool"},
	 { "SBCommunication_SetCloseOnEOF", _wrap_SBCommunication_SetCloseOnEOF, METH_VARARGS, "SBCommunication_SetCloseOnEOF(SBCommunication self, bool b)"},
	 { "SBCommunication_Read", _wrap_SBCommunication_Read, METH_VARARGS, "SBCommunication_Read(SBCommunication self, void * dst, size_t dst_len, uint32_t timeout_usec, lldb::ConnectionStatus & status) -> size_t"},
	 { "SBCommunication_Write", _wrap_SBCommunication_Write, METH_VARARGS, "SBCommunication_Write(SBCommunication self, void const * src, size_t src_len, lldb::ConnectionStatus & status) -> size_t"},
	 { "SBCommunication_ReadThreadStart", _wrap_SBCommunication_ReadThreadStart, METH_O, "SBCommunication_ReadThreadStart(SBCommunication self) -> bool"},
	 { "SBCommunication_ReadThreadStop", _wrap_SBCommunication_ReadThreadStop, METH_O, "SBCommunication_ReadThreadStop(SBCommunication self) -> bool"},
	 { "SBCommunication_ReadThreadIsRunning", _wrap_SBCommunication_ReadThreadIsRunning, METH_O, "SBCommunication_ReadThreadIsRunning(SBCommunication self) -> bool"},
	 { "SBCommunication_SetReadThreadBytesReceivedCallback", _wrap_SBCommunication_SetReadThreadBytesReceivedCallback, METH_VARARGS, "SBCommunication_SetReadThreadBytesReceivedCallback(SBCommunication self, lldb::SBCommunication::ReadThreadBytesReceived callback, void * callback_baton) -> bool"},
	 { "SBCommunication_swigregister", SBCommunication_swigregister, METH_O, NULL},
	 { "SBCommunication_swiginit", SBCommunication_swiginit, METH_VARARGS, NULL},
	 { "new_SBCompileUnit", _wrap_new_SBCompileUnit, METH_VARARGS, "\n"
		"SBCompileUnit()\n"
		"new_SBCompileUnit(SBCompileUnit rhs) -> SBCompileUnit\n"
		""},
	 { "delete_SBCompileUnit", _wrap_delete_SBCompileUnit, METH_O, "delete_SBCompileUnit(SBCompileUnit self)"},
	 { "SBCompileUnit___nonzero__", _wrap_SBCompileUnit___nonzero__, METH_O, "SBCompileUnit___nonzero__(SBCompileUnit self) -> bool"},
	 { "SBCompileUnit_IsValid", _wrap_SBCompileUnit_IsValid, METH_O, "SBCompileUnit_IsValid(SBCompileUnit self) -> bool"},
	 { "SBCompileUnit_GetFileSpec", _wrap_SBCompileUnit_GetFileSpec, METH_O, "SBCompileUnit_GetFileSpec(SBCompileUnit self) -> SBFileSpec"},
	 { "SBCompileUnit_GetNumLineEntries", _wrap_SBCompileUnit_GetNumLineEntries, METH_O, "SBCompileUnit_GetNumLineEntries(SBCompileUnit self) -> uint32_t"},
	 { "SBCompileUnit_GetLineEntryAtIndex", _wrap_SBCompileUnit_GetLineEntryAtIndex, METH_VARARGS, "SBCompileUnit_GetLineEntryAtIndex(SBCompileUnit self, uint32_t idx) -> SBLineEntry"},
	 { "SBCompileUnit_FindLineEntryIndex", _wrap_SBCompileUnit_FindLineEntryIndex, METH_VARARGS, "\n"
		"SBCompileUnit_FindLineEntryIndex(SBCompileUnit self, SBLineEntry line_entry, bool exact=False) -> uint32_t\n"
		"SBCompileUnit_FindLineEntryIndex(SBCompileUnit self, uint32_t start_idx, uint32_t line, SBFileSpec inline_file_spec) -> uint32_t\n"
		"SBCompileUnit_FindLineEntryIndex(SBCompileUnit self, uint32_t start_idx, uint32_t line, SBFileSpec inline_file_spec, bool exact) -> uint32_t\n"
		"\n"
		"     Get the index for a provided line entry in this compile unit.\n"
		"\n"
		"     @param[in] line_entry\n"
		"        The SBLineEntry object for which we are looking for the index.\n"
		"\n"
		"     @param[in] exact\n"
		"        An optional boolean defaulting to false that ensures that the provided\n"
		"        line entry has a perfect match in the compile unit.\n"
		"\n"
		"     @return\n"
		"        The index of the user-provided line entry. UINT32_MAX if the line entry\n"
		"        was not found in the compile unit.\n"
		""},
	 { "SBCompileUnit_GetSupportFileAtIndex", _wrap_SBCompileUnit_GetSupportFileAtIndex, METH_VARARGS, "SBCompileUnit_GetSupportFileAtIndex(SBCompileUnit self, uint32_t idx) -> SBFileSpec"},
	 { "SBCompileUnit_GetNumSupportFiles", _wrap_SBCompileUnit_GetNumSupportFiles, METH_O, "SBCompileUnit_GetNumSupportFiles(SBCompileUnit self) -> uint32_t"},
	 { "SBCompileUnit_FindSupportFileIndex", _wrap_SBCompileUnit_FindSupportFileIndex, METH_VARARGS, "SBCompileUnit_FindSupportFileIndex(SBCompileUnit self, uint32_t start_idx, SBFileSpec sb_file, bool full) -> uint32_t"},
	 { "SBCompileUnit_GetTypes", _wrap_SBCompileUnit_GetTypes, METH_VARARGS, "\n"
		"SBCompileUnit_GetTypes(SBCompileUnit self, uint32_t type_mask=eTypeClassAny) -> SBTypeList\n"
		"\n"
		"     Get all types matching type_mask from debug info in this\n"
		"     compile unit.\n"
		"\n"
		"     @param[in] type_mask\n"
		"        A bitfield that consists of one or more bits logically OR'ed\n"
		"        together from the lldb::TypeClass enumeration. This allows\n"
		"        you to request only structure types, or only class, struct\n"
		"        and union types. Passing in lldb::eTypeClassAny will return\n"
		"        all types found in the debug information for this compile\n"
		"        unit.\n"
		"\n"
		"     @return\n"
		"        A list of types in this compile unit that match type_mask\n"
		""},
	 { "SBCompileUnit_GetLanguage", _wrap_SBCompileUnit_GetLanguage, METH_O, "SBCompileUnit_GetLanguage(SBCompileUnit self) -> lldb::LanguageType"},
	 { "SBCompileUnit___eq__", _wrap_SBCompileUnit___eq__, METH_VARARGS, "SBCompileUnit___eq__(SBCompileUnit self, SBCompileUnit rhs) -> bool"},
	 { "SBCompileUnit___ne__", _wrap_SBCompileUnit___ne__, METH_VARARGS, "SBCompileUnit___ne__(SBCompileUnit self, SBCompileUnit rhs) -> bool"},
	 { "SBCompileUnit_GetDescription", _wrap_SBCompileUnit_GetDescription, METH_VARARGS, "SBCompileUnit_GetDescription(SBCompileUnit self, SBStream description) -> bool"},
	 { "SBCompileUnit___repr__", _wrap_SBCompileUnit___repr__, METH_O, "SBCompileUnit___repr__(SBCompileUnit self) -> std::string"},
	 { "SBCompileUnit_swigregister", SBCompileUnit_swigregister, METH_O, NULL},
	 { "SBCompileUnit_swiginit", SBCompileUnit_swiginit, METH_VARARGS, NULL},
	 { "new_SBSaveCoreOptions", _wrap_new_SBSaveCoreOptions, METH_VARARGS, "\n"
		"SBSaveCoreOptions()\n"
		"new_SBSaveCoreOptions(SBSaveCoreOptions rhs) -> SBSaveCoreOptions\n"
		""},
	 { "delete_SBSaveCoreOptions", _wrap_delete_SBSaveCoreOptions, METH_O, "delete_SBSaveCoreOptions(SBSaveCoreOptions self)"},
	 { "SBSaveCoreOptions_SetPluginName", _wrap_SBSaveCoreOptions_SetPluginName, METH_VARARGS, "\n"
		"SBSaveCoreOptions_SetPluginName(SBSaveCoreOptions self, char const * plugin) -> SBError\n"
		"\n"
		"    Set the plugin name to save a Core file with. Only plugins registered with Plugin manager will be accepted\n"
		"    Examples are Minidump and Mach-O.\n"
		""},
	 { "SBSaveCoreOptions_GetPluginName", _wrap_SBSaveCoreOptions_GetPluginName, METH_O, "\n"
		"SBSaveCoreOptions_GetPluginName(SBSaveCoreOptions self) -> char const *\n"
		"\n"
		"    Get the specified plugin name, or None if the name is not set.\n"
		""},
	 { "SBSaveCoreOptions_SetStyle", _wrap_SBSaveCoreOptions_SetStyle, METH_VARARGS, "\n"
		"SBSaveCoreOptions_SetStyle(SBSaveCoreOptions self, lldb::SaveCoreStyle style)\n"
		"\n"
		"    Set the lldb.SaveCoreStyle.\n"
		""},
	 { "SBSaveCoreOptions_GetStyle", _wrap_SBSaveCoreOptions_GetStyle, METH_O, "\n"
		"SBSaveCoreOptions_GetStyle(SBSaveCoreOptions self) -> lldb::SaveCoreStyle\n"
		"\n"
		"    Get the specified lldb.SaveCoreStyle, or eSaveCoreUnspecified if not set.\n"
		""},
	 { "SBSaveCoreOptions_SetOutputFile", _wrap_SBSaveCoreOptions_SetOutputFile, METH_VARARGS, "\n"
		"SBSaveCoreOptions_SetOutputFile(SBSaveCoreOptions self, SBFileSpec output_file)\n"
		"\n"
		"    Set the file path to save the Core file at.\n"
		""},
	 { "SBSaveCoreOptions_GetOutputFile", _wrap_SBSaveCoreOptions_GetOutputFile, METH_O, "\n"
		"SBSaveCoreOptions_GetOutputFile(SBSaveCoreOptions self) -> SBFileSpec\n"
		"\n"
		"    Get an SBFileSpec corresponding to the specified output path, or none if not set.\n"
		""},
	 { "SBSaveCoreOptions_SetProcess", _wrap_SBSaveCoreOptions_SetProcess, METH_VARARGS, "\n"
		"SBSaveCoreOptions_SetProcess(SBSaveCoreOptions self, SBProcess process) -> SBError\n"
		"\n"
		"    Set the process to save, or unset a process by providing a default SBProcess. \n"
		"    Resetting will result in the reset of all process specific options, such as Threads to save.\n"
		""},
	 { "SBSaveCoreOptions_GetProcess", _wrap_SBSaveCoreOptions_GetProcess, METH_O, "\n"
		"SBSaveCoreOptions_GetProcess(SBSaveCoreOptions self) -> SBProcess\n"
		"\n"
		"    Get the process to save. If a process is not defined, whether by calling clear or by not setting a process, an invalid process will be returned.\n"
		""},
	 { "SBSaveCoreOptions_AddThread", _wrap_SBSaveCoreOptions_AddThread, METH_VARARGS, "\n"
		"SBSaveCoreOptions_AddThread(SBSaveCoreOptions self, SBThread thread) -> SBError\n"
		"\n"
		"    Add an SBThread to be saved, an error will be returned if an SBThread from a different process is specified. \n"
		"    The process is set either by the first SBThread added to the options container, or explicitly by the SetProcess call.\n"
		""},
	 { "SBSaveCoreOptions_RemoveThread", _wrap_SBSaveCoreOptions_RemoveThread, METH_VARARGS, "\n"
		"SBSaveCoreOptions_RemoveThread(SBSaveCoreOptions self, SBThread thread) -> bool\n"
		"\n"
		"    Remove an SBthread if present in the container, returns true if a matching thread was found and removed.\n"
		""},
	 { "SBSaveCoreOptions_AddMemoryRegionToSave", _wrap_SBSaveCoreOptions_AddMemoryRegionToSave, METH_VARARGS, "\n"
		"SBSaveCoreOptions_AddMemoryRegionToSave(SBSaveCoreOptions self, SBMemoryRegionInfo region) -> SBError\n"
		"\n"
		"    Add a memory region to save, an error will be returned in the region is invalid. \n"
		"    Ranges that overlap will be unioned into a single region.\n"
		""},
	 { "SBSaveCoreOptions_GetThreadsToSave", _wrap_SBSaveCoreOptions_GetThreadsToSave, METH_O, "\n"
		"SBSaveCoreOptions_GetThreadsToSave(SBSaveCoreOptions self) -> SBThreadCollection\n"
		"\n"
		"    Get an SBThreadCollection of all threads marked to be saved. This collection is not sorted according to insertion order.\n"
		""},
	 { "SBSaveCoreOptions_GetMemoryRegionsToSave", _wrap_SBSaveCoreOptions_GetMemoryRegionsToSave, METH_O, "\n"
		"SBSaveCoreOptions_GetMemoryRegionsToSave(SBSaveCoreOptions self) -> SBMemoryRegionInfoList\n"
		"\n"
		"    Get an SBMemoryRegionInfoList of all the Regions that LLDB will attempt to write into the Core. Note, reading from these\n"
		"    regions can fail, and it's not guaraunteed every region will be present in the resulting core. If called without a valid process or style set an empty\n"
		"    collection will be returned.\n"
		""},
	 { "SBSaveCoreOptions_GetCurrentSizeInBytes", _wrap_SBSaveCoreOptions_GetCurrentSizeInBytes, METH_VARARGS, "\n"
		"SBSaveCoreOptions_GetCurrentSizeInBytes(SBSaveCoreOptions self, SBError error) -> uint64_t\n"
		"\n"
		"    Get the current total number of bytes the core is expected to have, excluding the overhead of the core file format.\n"
		"    Requires both a Process and a Style to be specified. An error will be returned if the provided options would result in no data being saved.\n"
		""},
	 { "SBSaveCoreOptions_Clear", _wrap_SBSaveCoreOptions_Clear, METH_O, "\n"
		"SBSaveCoreOptions_Clear(SBSaveCoreOptions self)\n"
		"\n"
		"    Unset all options.\n"
		""},
	 { "SBSaveCoreOptions_swigregister", SBSaveCoreOptions_swigregister, METH_O, NULL},
	 { "SBSaveCoreOptions_swiginit", SBSaveCoreOptions_swiginit, METH_VARARGS, NULL},
	 { "new_SBData", _wrap_new_SBData, METH_VARARGS, "\n"
		"SBData()\n"
		"new_SBData(SBData rhs) -> SBData\n"
		""},
	 { "delete_SBData", _wrap_delete_SBData, METH_O, "delete_SBData(SBData self)"},
	 { "SBData_GetAddressByteSize", _wrap_SBData_GetAddressByteSize, METH_O, "SBData_GetAddressByteSize(SBData self) -> uint8_t"},
	 { "SBData_SetAddressByteSize", _wrap_SBData_SetAddressByteSize, METH_VARARGS, "SBData_SetAddressByteSize(SBData self, uint8_t addr_byte_size)"},
	 { "SBData_Clear", _wrap_SBData_Clear, METH_O, "SBData_Clear(SBData self)"},
	 { "SBData___nonzero__", _wrap_SBData___nonzero__, METH_O, "SBData___nonzero__(SBData self) -> bool"},
	 { "SBData_IsValid", _wrap_SBData_IsValid, METH_O, "SBData_IsValid(SBData self) -> bool"},
	 { "SBData_GetByteSize", _wrap_SBData_GetByteSize, METH_O, "SBData_GetByteSize(SBData self) -> size_t"},
	 { "SBData_GetByteOrder", _wrap_SBData_GetByteOrder, METH_O, "SBData_GetByteOrder(SBData self) -> lldb::ByteOrder"},
	 { "SBData_SetByteOrder", _wrap_SBData_SetByteOrder, METH_VARARGS, "SBData_SetByteOrder(SBData self, lldb::ByteOrder endian)"},
	 { "SBData_GetFloat", _wrap_SBData_GetFloat, METH_VARARGS, "SBData_GetFloat(SBData self, SBError error, lldb::offset_t offset) -> float"},
	 { "SBData_GetDouble", _wrap_SBData_GetDouble, METH_VARARGS, "SBData_GetDouble(SBData self, SBError error, lldb::offset_t offset) -> double"},
	 { "SBData_GetLongDouble", _wrap_SBData_GetLongDouble, METH_VARARGS, "SBData_GetLongDouble(SBData self, SBError error, lldb::offset_t offset) -> long double"},
	 { "SBData_GetAddress", _wrap_SBData_GetAddress, METH_VARARGS, "SBData_GetAddress(SBData self, SBError error, lldb::offset_t offset) -> lldb::addr_t"},
	 { "SBData_GetUnsignedInt8", _wrap_SBData_GetUnsignedInt8, METH_VARARGS, "SBData_GetUnsignedInt8(SBData self, SBError error, lldb::offset_t offset) -> uint8_t"},
	 { "SBData_GetUnsignedInt16", _wrap_SBData_GetUnsignedInt16, METH_VARARGS, "SBData_GetUnsignedInt16(SBData self, SBError error, lldb::offset_t offset) -> uint16_t"},
	 { "SBData_GetUnsignedInt32", _wrap_SBData_GetUnsignedInt32, METH_VARARGS, "SBData_GetUnsignedInt32(SBData self, SBError error, lldb::offset_t offset) -> uint32_t"},
	 { "SBData_GetUnsignedInt64", _wrap_SBData_GetUnsignedInt64, METH_VARARGS, "SBData_GetUnsignedInt64(SBData self, SBError error, lldb::offset_t offset) -> uint64_t"},
	 { "SBData_GetSignedInt8", _wrap_SBData_GetSignedInt8, METH_VARARGS, "SBData_GetSignedInt8(SBData self, SBError error, lldb::offset_t offset) -> int8_t"},
	 { "SBData_GetSignedInt16", _wrap_SBData_GetSignedInt16, METH_VARARGS, "SBData_GetSignedInt16(SBData self, SBError error, lldb::offset_t offset) -> int16_t"},
	 { "SBData_GetSignedInt32", _wrap_SBData_GetSignedInt32, METH_VARARGS, "SBData_GetSignedInt32(SBData self, SBError error, lldb::offset_t offset) -> int32_t"},
	 { "SBData_GetSignedInt64", _wrap_SBData_GetSignedInt64, METH_VARARGS, "SBData_GetSignedInt64(SBData self, SBError error, lldb::offset_t offset) -> int64_t"},
	 { "SBData_GetString", _wrap_SBData_GetString, METH_VARARGS, "SBData_GetString(SBData self, SBError error, lldb::offset_t offset) -> char const *"},
	 { "SBData_ReadRawData", _wrap_SBData_ReadRawData, METH_VARARGS, "SBData_ReadRawData(SBData self, SBError error, lldb::offset_t offset, void * buf) -> size_t"},
	 { "SBData_GetDescription", _wrap_SBData_GetDescription, METH_VARARGS, "SBData_GetDescription(SBData self, SBStream description, lldb::addr_t base_addr=18446744073709551615ULL) -> bool"},
	 { "SBData_SetData", _wrap_SBData_SetData, METH_VARARGS, "SBData_SetData(SBData self, SBError error, void const * buf, lldb::ByteOrder endian, uint8_t addr_size)"},
	 { "SBData_SetDataWithOwnership", _wrap_SBData_SetDataWithOwnership, METH_VARARGS, "SBData_SetDataWithOwnership(SBData self, SBError error, void const * buf, lldb::ByteOrder endian, uint8_t addr_size)"},
	 { "SBData_Append", _wrap_SBData_Append, METH_VARARGS, "SBData_Append(SBData self, SBData rhs) -> bool"},
	 { "SBData_CreateDataFromCString", _wrap_SBData_CreateDataFromCString, METH_VARARGS, "SBData_CreateDataFromCString(lldb::ByteOrder endian, uint32_t addr_byte_size, char const * data) -> SBData"},
	 { "SBData_CreateDataFromUInt64Array", _wrap_SBData_CreateDataFromUInt64Array, METH_VARARGS, "SBData_CreateDataFromUInt64Array(lldb::ByteOrder endian, uint32_t addr_byte_size, uint64_t * array) -> SBData"},
	 { "SBData_CreateDataFromUInt32Array", _wrap_SBData_CreateDataFromUInt32Array, METH_VARARGS, "SBData_CreateDataFromUInt32Array(lldb::ByteOrder endian, uint32_t addr_byte_size, uint32_t * array) -> SBData"},
	 { "SBData_CreateDataFromSInt64Array", _wrap_SBData_CreateDataFromSInt64Array, METH_VARARGS, "SBData_CreateDataFromSInt64Array(lldb::ByteOrder endian, uint32_t addr_byte_size, int64_t * array) -> SBData"},
	 { "SBData_CreateDataFromSInt32Array", _wrap_SBData_CreateDataFromSInt32Array, METH_VARARGS, "SBData_CreateDataFromSInt32Array(lldb::ByteOrder endian, uint32_t addr_byte_size, int32_t * array) -> SBData"},
	 { "SBData_CreateDataFromDoubleArray", _wrap_SBData_CreateDataFromDoubleArray, METH_VARARGS, "SBData_CreateDataFromDoubleArray(lldb::ByteOrder endian, uint32_t addr_byte_size, double * array) -> SBData"},
	 { "SBData_SetDataFromCString", _wrap_SBData_SetDataFromCString, METH_VARARGS, "SBData_SetDataFromCString(SBData self, char const * data) -> bool"},
	 { "SBData_SetDataFromUInt64Array", _wrap_SBData_SetDataFromUInt64Array, METH_VARARGS, "SBData_SetDataFromUInt64Array(SBData self, uint64_t * array) -> bool"},
	 { "SBData_SetDataFromUInt32Array", _wrap_SBData_SetDataFromUInt32Array, METH_VARARGS, "SBData_SetDataFromUInt32Array(SBData self, uint32_t * array) -> bool"},
	 { "SBData_SetDataFromSInt64Array", _wrap_SBData_SetDataFromSInt64Array, METH_VARARGS, "SBData_SetDataFromSInt64Array(SBData self, int64_t * array) -> bool"},
	 { "SBData_SetDataFromSInt32Array", _wrap_SBData_SetDataFromSInt32Array, METH_VARARGS, "SBData_SetDataFromSInt32Array(SBData self, int32_t * array) -> bool"},
	 { "SBData_SetDataFromDoubleArray", _wrap_SBData_SetDataFromDoubleArray, METH_VARARGS, "SBData_SetDataFromDoubleArray(SBData self, double * array) -> bool"},
	 { "SBData___repr__", _wrap_SBData___repr__, METH_O, "SBData___repr__(SBData self) -> std::string"},
	 { "SBData_swigregister", SBData_swigregister, METH_O, NULL},
	 { "SBData_swiginit", SBData_swiginit, METH_VARARGS, NULL},
	 { "new_SBDebugger", _wrap_new_SBDebugger, METH_VARARGS, "\n"
		"SBDebugger()\n"
		"new_SBDebugger(SBDebugger rhs) -> SBDebugger\n"
		""},
	 { "delete_SBDebugger", _wrap_delete_SBDebugger, METH_O, "delete_SBDebugger(SBDebugger self)"},
	 { "SBDebugger_GetBroadcasterClass", _wrap_SBDebugger_GetBroadcasterClass, METH_NOARGS, "Get the broadcaster class name."},
	 { "SBDebugger_SupportsLanguage", _wrap_SBDebugger_SupportsLanguage, METH_O, "Check if a specific language is supported by LLDB."},
	 { "SBDebugger_GetBroadcaster", _wrap_SBDebugger_GetBroadcaster, METH_O, "\n"
		"Get the broadcaster that allows subscribing to events from this\n"
		"debugger.\n"
		""},
	 { "SBDebugger_GetProgressFromEvent", _wrap_SBDebugger_GetProgressFromEvent, METH_O, "\n"
		"Get progress data from a SBEvent whose type is eBroadcastBitProgress.\n"
		"\n"
		":param [in]: event\n"
		"      The event to extract the progress information from.\n"
		"\n"
		":param [out]: progress_id\n"
		"      The unique integer identifier for the progress to report.\n"
		"\n"
		":param [out]: completed\n"
		"      The amount of work completed. If *completed* is zero, then this event\n"
		"      is a progress started event. If *completed* is equal to *total*, then\n"
		"      this event is a progress end event. Otherwise completed indicates the\n"
		"      current progress update.\n"
		"\n"
		":param [out]: total\n"
		"      The total amount of work units that need to be completed. If this value\n"
		"      is UINT64_MAX, then an indeterminate progress indicator should be\n"
		"      displayed.\n"
		"\n"
		":param [out]: is_debugger_specific\n"
		"      Set to true if this progress is specific to this debugger only. Many\n"
		"      progress events are not specific to a debugger instance, like any\n"
		"      progress events for loading information in modules since LLDB has a\n"
		"      global module cache that all debuggers use.\n"
		"\n"
		":rtype: string\n"
		":return: The message for the progress. If the returned value is NULL, then\n"
		"      *event* was not a eBroadcastBitProgress event.\n"
		""},
	 { "SBDebugger_GetProgressDataFromEvent", _wrap_SBDebugger_GetProgressDataFromEvent, METH_O, "Get progress data from an event."},
	 { "SBDebugger_GetDiagnosticFromEvent", _wrap_SBDebugger_GetDiagnosticFromEvent, METH_O, "Get diagnostic information from an event."},
	 { "SBDebugger_Initialize", _wrap_SBDebugger_Initialize, METH_NOARGS, "\n"
		"Initialize LLDB and its subsystems.\n"
		"\n"
		"This function should be called before any other LLDB functions. It\n"
		"initializes all required subsystems for proper LLDB functionality.\n"
		""},
	 { "SBDebugger_InitializeWithErrorHandling", _wrap_SBDebugger_InitializeWithErrorHandling, METH_NOARGS, "\n"
		"Initialize the LLDB debugger subsystem with error handling.\n"
		"\n"
		"Similar to Initialize(), but returns an error if initialization fails.\n"
		""},
	 { "SBDebugger_PrintStackTraceOnError", _wrap_SBDebugger_PrintStackTraceOnError, METH_NOARGS, "Configure LLDB to print a stack trace when it crashes."},
	 { "SBDebugger_PrintDiagnosticsOnError", _wrap_SBDebugger_PrintDiagnosticsOnError, METH_NOARGS, "Configure LLDB to print diagnostic information when it crashes."},
	 { "SBDebugger_Terminate", _wrap_SBDebugger_Terminate, METH_NOARGS, "\n"
		"Terminate LLDB and its subsystems.\n"
		"\n"
		"This should be called when LLDB is no longer needed.\n"
		""},
	 { "SBDebugger_Create", _wrap_SBDebugger_Create, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		"Create a new debugger instance (deprecated).\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		"Create a new debugger instance.\n"
		"\n"
		"If source_init_files is true, the debugger will source .lldbinit files\n"
		"from the home directory and current directory.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		"Create a new debugger instance with a custom log handler and user data\n"
		"passed to the log callback.\n"
		"\n"
		"If source_init_files is true, the debugger will source .lldbinit files\n"
		"from the home directory and current directory.\n"
		""},
	 { "SBDebugger_Destroy", _wrap_SBDebugger_Destroy, METH_O, "Destroy a debugger instance."},
	 { "SBDebugger_MemoryPressureDetected", _wrap_SBDebugger_MemoryPressureDetected, METH_NOARGS, "\n"
		"Notify the debugger that system memory pressure has been detected.\n"
		"\n"
		"This can be used to free up memory resources by clearing caches.\n"
		""},
	 { "SBDebugger___nonzero__", _wrap_SBDebugger___nonzero__, METH_O, "Check if this is a valid SBDebugger object."},
	 { "SBDebugger_IsValid", _wrap_SBDebugger_IsValid, METH_O, "Check if this is a valid SBDebugger object."},
	 { "SBDebugger_Clear", _wrap_SBDebugger_Clear, METH_O, "\n"
		"Clear this debugger instance.\n"
		"\n"
		"This will close all IO handlers and reset the debugger to its initial\n"
		"state.\n"
		""},
	 { "SBDebugger_GetSetting", _wrap_SBDebugger_GetSetting, METH_VARARGS, "\n"
		"Get debugger settings as structured data.\n"
		"\n"
		"Client can specify empty string or null to get all settings.\n"
		"\n"
		"Example usages:\n"
		"lldb::SBStructuredData settings = debugger.GetSetting();\n"
		"lldb::SBStructuredData settings = debugger.GetSetting(nullptr);\n"
		"lldb::SBStructuredData settings = debugger.GetSetting(\"\");\n"
		"lldb::SBStructuredData settings = debugger.GetSetting(\"target.arg0\");\n"
		"lldb::SBStructuredData settings = debugger.GetSetting(\"target\");\n"
		""},
	 { "SBDebugger_SetAsync", _wrap_SBDebugger_SetAsync, METH_VARARGS, "\n"
		"Set whether the debugger should run in asynchronous mode.\n"
		"\n"
		"When in asynchronous mode, events are processed on a background thread.\n"
		""},
	 { "SBDebugger_GetAsync", _wrap_SBDebugger_GetAsync, METH_O, "Get whether the debugger is running in asynchronous mode."},
	 { "SBDebugger_SkipLLDBInitFiles", _wrap_SBDebugger_SkipLLDBInitFiles, METH_VARARGS, "Set whether to skip loading .lldbinit files."},
	 { "SBDebugger_SkipAppInitFiles", _wrap_SBDebugger_SkipAppInitFiles, METH_VARARGS, "Set whether to skip loading application-specific .lldbinit files."},
	 { "SBDebugger_SetInputString", _wrap_SBDebugger_SetInputString, METH_VARARGS, "Set the input from a string."},
	 { "SBDebugger_SetInputFile", _wrap_SBDebugger_SetInputFile, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		"Set the input file for the debugger.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		"Set the input file for the debugger using a FileSP.\n"
		""},
	 { "SBDebugger_SetOutputFile", _wrap_SBDebugger_SetOutputFile, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		"Set the output file for the debugger.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		"Set the output file for the debugger using a FileSP.\n"
		""},
	 { "SBDebugger_SetErrorFile", _wrap_SBDebugger_SetErrorFile, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		"Set the error file for the debugger.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		"Set the error file for the debugger using a FileSP.\n"
		""},
	 { "SBDebugger_GetInputFile", _wrap_SBDebugger_GetInputFile, METH_O, "Get the input file for the debugger."},
	 { "SBDebugger_GetOutputFile", _wrap_SBDebugger_GetOutputFile, METH_O, "Get the output file for the debugger."},
	 { "SBDebugger_GetErrorFile", _wrap_SBDebugger_GetErrorFile, METH_O, "Get the error file for the debugger."},
	 { "SBDebugger_SaveInputTerminalState", _wrap_SBDebugger_SaveInputTerminalState, METH_O, "\n"
		"Save the current terminal state.\n"
		"\n"
		"This should be called before modifying terminal settings.\n"
		""},
	 { "SBDebugger_RestoreInputTerminalState", _wrap_SBDebugger_RestoreInputTerminalState, METH_O, "Restore the previously saved terminal state."},
	 { "SBDebugger_GetCommandInterpreter", _wrap_SBDebugger_GetCommandInterpreter, METH_O, "Get the command interpreter for this debugger."},
	 { "SBDebugger_HandleCommand", _wrap_SBDebugger_HandleCommand, METH_VARARGS, "Execute a command in the command interpreter."},
	 { "SBDebugger_RequestInterrupt", _wrap_SBDebugger_RequestInterrupt, METH_O, "Request an interrupt of the current operation."},
	 { "SBDebugger_CancelInterruptRequest", _wrap_SBDebugger_CancelInterruptRequest, METH_O, "Cancel a previously requested interrupt."},
	 { "SBDebugger_InterruptRequested", _wrap_SBDebugger_InterruptRequested, METH_O, "Check if an interrupt has been requested."},
	 { "SBDebugger_GetListener", _wrap_SBDebugger_GetListener, METH_O, "Get the listener associated with this debugger."},
	 { "SBDebugger_HandleProcessEvent", _wrap_SBDebugger_HandleProcessEvent, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		"Handle a process event.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		"Handle a process event using FileSP objects.\n"
		""},
	 { "SBDebugger_CreateTargetWithFileAndTargetTriple", _wrap_SBDebugger_CreateTargetWithFileAndTargetTriple, METH_VARARGS, "Create a target with the specified file and target triple."},
	 { "SBDebugger_CreateTargetWithFileAndArch", _wrap_SBDebugger_CreateTargetWithFileAndArch, METH_VARARGS, "Create a target with the specified file and architecture."},
	 { "SBDebugger_CreateTarget", _wrap_SBDebugger_CreateTarget, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		"Create a target with the specified parameters.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		"Create a target with the specified file.\n"
		""},
	 { "SBDebugger_GetDummyTarget", _wrap_SBDebugger_GetDummyTarget, METH_O, "\n"
		"SBDebugger_GetDummyTarget(SBDebugger self) -> SBTarget\n"
		"The dummy target holds breakpoints and breakpoint names that will prime newly created targets.\n"
		""},
	 { "SBDebugger_DeleteTarget", _wrap_SBDebugger_DeleteTarget, METH_VARARGS, "\n"
		"SBDebugger_DeleteTarget(SBDebugger self, SBTarget target) -> bool\n"
		"Return true if target is deleted from the target list of the debugger.\n"
		""},
	 { "SBDebugger_GetTargetAtIndex", _wrap_SBDebugger_GetTargetAtIndex, METH_VARARGS, "Get a target by index."},
	 { "SBDebugger_GetIndexOfTarget", _wrap_SBDebugger_GetIndexOfTarget, METH_VARARGS, "Get the index of a target."},
	 { "SBDebugger_FindTargetWithProcessID", _wrap_SBDebugger_FindTargetWithProcessID, METH_VARARGS, "Find a target with the specified process ID."},
	 { "SBDebugger_FindTargetWithFileAndArch", _wrap_SBDebugger_FindTargetWithFileAndArch, METH_VARARGS, "Find a target with the specified file and architecture."},
	 { "SBDebugger_FindTargetByGloballyUniqueID", _wrap_SBDebugger_FindTargetByGloballyUniqueID, METH_VARARGS, "Find a target with the specified unique ID."},
	 { "SBDebugger_GetNumTargets", _wrap_SBDebugger_GetNumTargets, METH_O, "Get the number of targets in the debugger."},
	 { "SBDebugger_GetSelectedTarget", _wrap_SBDebugger_GetSelectedTarget, METH_O, "Get the currently selected target."},
	 { "SBDebugger_SetSelectedTarget", _wrap_SBDebugger_SetSelectedTarget, METH_VARARGS, "Set the selected target."},
	 { "SBDebugger_GetSelectedPlatform", _wrap_SBDebugger_GetSelectedPlatform, METH_O, "Get the selected platform."},
	 { "SBDebugger_SetSelectedPlatform", _wrap_SBDebugger_SetSelectedPlatform, METH_VARARGS, "Set the selected platform."},
	 { "SBDebugger_GetNumPlatforms", _wrap_SBDebugger_GetNumPlatforms, METH_O, "\n"
		"SBDebugger_GetNumPlatforms(SBDebugger self) -> uint32_t\n"
		"Get the number of currently active platforms.\n"
		""},
	 { "SBDebugger_GetPlatformAtIndex", _wrap_SBDebugger_GetPlatformAtIndex, METH_VARARGS, "\n"
		"SBDebugger_GetPlatformAtIndex(SBDebugger self, uint32_t idx) -> SBPlatform\n"
		"Get one of the currently active platforms.\n"
		""},
	 { "SBDebugger_GetNumAvailablePlatforms", _wrap_SBDebugger_GetNumAvailablePlatforms, METH_O, "\n"
		"SBDebugger_GetNumAvailablePlatforms(SBDebugger self) -> uint32_t\n"
		"Get the number of available platforms.\n"
		""},
	 { "SBDebugger_GetAvailablePlatformInfoAtIndex", _wrap_SBDebugger_GetAvailablePlatformInfoAtIndex, METH_VARARGS, "\n"
		"SBDebugger_GetAvailablePlatformInfoAtIndex(SBDebugger self, uint32_t idx) -> SBStructuredData\n"
		"\n"
		"    Get the name and description of one of the available platforms.\n"
		"\n"
		"    @param idx Zero-based index of the platform for which info should be\n"
		"               retrieved, must be less than the value returned by\n"
		"               GetNumAvailablePlatforms().\n"
		""},
	 { "SBDebugger_GetSourceManager", _wrap_SBDebugger_GetSourceManager, METH_O, "Get the source manager for this debugger."},
	 { "SBDebugger_SetCurrentPlatform", _wrap_SBDebugger_SetCurrentPlatform, METH_VARARGS, "Set the current platform by name."},
	 { "SBDebugger_SetCurrentPlatformSDKRoot", _wrap_SBDebugger_SetCurrentPlatformSDKRoot, METH_VARARGS, "Set the SDK root for the current platform."},
	 { "SBDebugger_SetUseExternalEditor", _wrap_SBDebugger_SetUseExternalEditor, METH_VARARGS, "Set whether to use an external editor."},
	 { "SBDebugger_GetUseExternalEditor", _wrap_SBDebugger_GetUseExternalEditor, METH_O, "Get whether an external editor is being used."},
	 { "SBDebugger_SetUseColor", _wrap_SBDebugger_SetUseColor, METH_VARARGS, "Set whether to use color in output."},
	 { "SBDebugger_GetUseColor", _wrap_SBDebugger_GetUseColor, METH_O, "Get whether color is being used in output."},
	 { "SBDebugger_SetShowInlineDiagnostics", _wrap_SBDebugger_SetShowInlineDiagnostics, METH_VARARGS, "Set whether to show inline diagnostics."},
	 { "SBDebugger_SetUseSourceCache", _wrap_SBDebugger_SetUseSourceCache, METH_VARARGS, "Set whether to use the source cache."},
	 { "SBDebugger_GetUseSourceCache", _wrap_SBDebugger_GetUseSourceCache, METH_O, "Get whether the source cache is being used."},
	 { "SBDebugger_GetDefaultArchitecture", _wrap_SBDebugger_GetDefaultArchitecture, METH_VARARGS, "Get the default architecture."},
	 { "SBDebugger_SetDefaultArchitecture", _wrap_SBDebugger_SetDefaultArchitecture, METH_O, "Set the default architecture."},
	 { "SBDebugger_GetScriptingLanguage", _wrap_SBDebugger_GetScriptingLanguage, METH_VARARGS, "Get the scripting language by name."},
	 { "SBDebugger_GetScriptInterpreterInfo", _wrap_SBDebugger_GetScriptInterpreterInfo, METH_VARARGS, "Get information about a script interpreter as structured data."},
	 { "SBDebugger_GetVersionString", _wrap_SBDebugger_GetVersionString, METH_NOARGS, "Get the LLDB version string."},
	 { "SBDebugger_StateAsCString", _wrap_SBDebugger_StateAsCString, METH_O, "Convert a state type to a string."},
	 { "SBDebugger_GetBuildConfiguration", _wrap_SBDebugger_GetBuildConfiguration, METH_NOARGS, "Get the build configuration as structured data."},
	 { "SBDebugger_StateIsRunningState", _wrap_SBDebugger_StateIsRunningState, METH_O, "Check if a state is a running state."},
	 { "SBDebugger_StateIsStoppedState", _wrap_SBDebugger_StateIsStoppedState, METH_O, "Check if a state is a stopped state."},
	 { "SBDebugger_EnableLog", _wrap_SBDebugger_EnableLog, METH_VARARGS, "Enable logging for a specific channel and category."},
	 { "SBDebugger_SetLoggingCallback", _wrap_SBDebugger_SetLoggingCallback, METH_VARARGS, "Set a callback for log output."},
	 { "SBDebugger_SetDestroyCallback", _wrap_SBDebugger_SetDestroyCallback, METH_VARARGS, "Set a callback for when the debugger is destroyed (deprecated)."},
	 { "SBDebugger_AddDestroyCallback", _wrap_SBDebugger_AddDestroyCallback, METH_VARARGS, "\n"
		"Add a callback for when the debugger is destroyed. Returns a token that\n"
		"can be used to remove the callback.\n"
		""},
	 { "SBDebugger_RemoveDestroyCallback", _wrap_SBDebugger_RemoveDestroyCallback, METH_VARARGS, "Remove a destroy callback."},
	 { "SBDebugger_DispatchInput", _wrap_SBDebugger_DispatchInput, METH_VARARGS, "Dispatch input to the debugger."},
	 { "SBDebugger_DispatchInputInterrupt", _wrap_SBDebugger_DispatchInputInterrupt, METH_O, "Interrupt the current input dispatch."},
	 { "SBDebugger_DispatchInputEndOfFile", _wrap_SBDebugger_DispatchInputEndOfFile, METH_O, "Signal end-of-file to the current input dispatch."},
	 { "SBDebugger_GetInstanceName", _wrap_SBDebugger_GetInstanceName, METH_O, "Get the instance name of this debugger."},
	 { "SBDebugger_FindDebuggerWithID", _wrap_SBDebugger_FindDebuggerWithID, METH_O, "Find a debugger by ID. Returns an invalid debugger if not found."},
	 { "SBDebugger_SetInternalVariable", _wrap_SBDebugger_SetInternalVariable, METH_VARARGS, "Set an internal variable."},
	 { "SBDebugger_GetInternalVariableValue", _wrap_SBDebugger_GetInternalVariableValue, METH_VARARGS, "Get the value of an internal variable."},
	 { "SBDebugger_GetDescription", _wrap_SBDebugger_GetDescription, METH_VARARGS, "Get a description of this debugger."},
	 { "SBDebugger_GetTerminalWidth", _wrap_SBDebugger_GetTerminalWidth, METH_O, "Get the terminal width."},
	 { "SBDebugger_SetTerminalWidth", _wrap_SBDebugger_SetTerminalWidth, METH_VARARGS, "Set the terminal width."},
	 { "SBDebugger_GetTerminalHeight", _wrap_SBDebugger_GetTerminalHeight, METH_O, "Get the terminal height."},
	 { "SBDebugger_SetTerminalHeight", _wrap_SBDebugger_SetTerminalHeight, METH_VARARGS, "Set the terminal height."},
	 { "SBDebugger_GetID", _wrap_SBDebugger_GetID, METH_O, "Get the unique ID of this debugger."},
	 { "SBDebugger_GetPrompt", _wrap_SBDebugger_GetPrompt, METH_O, "Get the command prompt string."},
	 { "SBDebugger_SetPrompt", _wrap_SBDebugger_SetPrompt, METH_VARARGS, "Set the command prompt string."},
	 { "SBDebugger_GetReproducerPath", _wrap_SBDebugger_GetReproducerPath, METH_O, "Get the path to the reproducer."},
	 { "SBDebugger_GetScriptLanguage", _wrap_SBDebugger_GetScriptLanguage, METH_O, "Get the current scripting language."},
	 { "SBDebugger_SetScriptLanguage", _wrap_SBDebugger_SetScriptLanguage, METH_VARARGS, "Set the current scripting language."},
	 { "SBDebugger_GetREPLLanguage", _wrap_SBDebugger_GetREPLLanguage, METH_O, "Get the current REPL language."},
	 { "SBDebugger_SetREPLLanguage", _wrap_SBDebugger_SetREPLLanguage, METH_VARARGS, "Set the current REPL language."},
	 { "SBDebugger_GetCloseInputOnEOF", _wrap_SBDebugger_GetCloseInputOnEOF, METH_O, "Get whether to close input on EOF (deprecated)."},
	 { "SBDebugger_SetCloseInputOnEOF", _wrap_SBDebugger_SetCloseInputOnEOF, METH_VARARGS, "Set whether to close input on EOF (deprecated)."},
	 { "SBDebugger_GetCategory", _wrap_SBDebugger_GetCategory, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		"Get a type category by name.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		"Get a type category by language.\n"
		""},
	 { "SBDebugger_CreateCategory", _wrap_SBDebugger_CreateCategory, METH_VARARGS, "Create a new type category."},
	 { "SBDebugger_DeleteCategory", _wrap_SBDebugger_DeleteCategory, METH_VARARGS, "Delete a type category."},
	 { "SBDebugger_GetNumCategories", _wrap_SBDebugger_GetNumCategories, METH_O, "Get the number of type categories."},
	 { "SBDebugger_GetCategoryAtIndex", _wrap_SBDebugger_GetCategoryAtIndex, METH_VARARGS, "Get a type category by index."},
	 { "SBDebugger_GetDefaultCategory", _wrap_SBDebugger_GetDefaultCategory, METH_O, "Get the default type category."},
	 { "SBDebugger_GetFormatForType", _wrap_SBDebugger_GetFormatForType, METH_VARARGS, "Get the format for a type."},
	 { "SBDebugger_GetSummaryForType", _wrap_SBDebugger_GetSummaryForType, METH_VARARGS, "Get the summary for a type."},
	 { "SBDebugger_GetFilterForType", _wrap_SBDebugger_GetFilterForType, METH_VARARGS, "Get the filter for a type."},
	 { "SBDebugger_GetSyntheticForType", _wrap_SBDebugger_GetSyntheticForType, METH_VARARGS, "Get the synthetic for a type."},
	 { "SBDebugger_ResetStatistics", _wrap_SBDebugger_ResetStatistics, METH_O, "\n"
		"Clear collected statistics for targets belonging to this debugger.\n"
		"\n"
		"This includes clearing symbol table and debug info parsing/index time for\n"
		"all modules, breakpoint resolve time, and target statistics.\n"
		""},
	 { "SBDebugger_RunCommandInterpreter", _wrap_SBDebugger_RunCommandInterpreter, METH_VARARGS, "\n"
		"SBDebugger_RunCommandInterpreter(SBDebugger self, bool auto_handle_events, bool spawn_thread, SBCommandInterpreterRunOptions options, int & num_errors, bool & quit_requested, bool & stopped_for_crash)\n"
		"Launch a command interpreter session. Commands are read from standard input or\n"
		"from the input handle specified for the debugger object. Output/errors are\n"
		"similarly redirected to standard output/error or the configured handles.\n"
		"\n"
		"@param[in] auto_handle_events If true, automatically handle resulting events.\n"
		"@param[in] spawn_thread If true, start a new thread for IO handling.\n"
		"@param[in] options Parameter collection of type SBCommandInterpreterRunOptions.\n"
		"@param[in] num_errors Initial error counter.\n"
		"@param[in] quit_requested Initial quit request flag.\n"
		"@param[in] stopped_for_crash Initial crash flag.\n"
		"\n"
		"@return\n"
		"A tuple with the number of errors encountered by the interpreter, a boolean\n"
		"indicating whether quitting the interpreter was requested and another boolean\n"
		"set to True in case of a crash.\n"
		"\n"
		"Example: ::\n"
		"\n"
		"    # Start an interactive lldb session from a script (with a valid debugger object\n"
		"    # created beforehand):\n"
		"    n_errors, quit_requested, has_crashed = debugger.RunCommandInterpreter(True,\n"
		"        False, lldb.SBCommandInterpreterRunOptions(), 0, False, False)\n"
		""},
	 { "SBDebugger_RunREPL", _wrap_SBDebugger_RunREPL, METH_VARARGS, "Run a REPL (Read-Eval-Print Loop) for the specified language."},
	 { "SBDebugger_LoadTraceFromFile", _wrap_SBDebugger_LoadTraceFromFile, METH_VARARGS, "\n"
		"Load a trace from a trace description file.\n"
		"\n"
		"This will create Targets, Processes and Threads based on the contents of\n"
		"the file.\n"
		"\n"
		":type error: :py:class:`SBError`, out\n"
		":param error:\n"
		"      An error if the trace could not be created.\n"
		"\n"
		":type trace_description_file: :py:class:`SBFileSpec`, in\n"
		":param trace_description_file:\n"
		"      The file containing the necessary information to load the trace.\n"
		"\n"
		":rtype: :py:class:`SBTrace`\n"
		":return: \n"
		"      An SBTrace object representing the loaded trace.\n"
		""},
	 { "SBDebugger___repr__", _wrap_SBDebugger___repr__, METH_O, "SBDebugger___repr__(SBDebugger self) -> std::string"},
	 { "SBDebugger_GetInputFileHandle", _wrap_SBDebugger_GetInputFileHandle, METH_O, "SBDebugger_GetInputFileHandle(SBDebugger self) -> lldb::FileSP"},
	 { "SBDebugger_GetOutputFileHandle", _wrap_SBDebugger_GetOutputFileHandle, METH_O, "SBDebugger_GetOutputFileHandle(SBDebugger self) -> lldb::FileSP"},
	 { "SBDebugger_GetErrorFileHandle", _wrap_SBDebugger_GetErrorFileHandle, METH_O, "SBDebugger_GetErrorFileHandle(SBDebugger self) -> lldb::FileSP"},
	 { "SBDebugger_swigregister", SBDebugger_swigregister, METH_O, NULL},
	 { "SBDebugger_swiginit", SBDebugger_swiginit, METH_VARARGS, NULL},
	 { "new_SBDeclaration", _wrap_new_SBDeclaration, METH_VARARGS, "\n"
		"SBDeclaration()\n"
		"new_SBDeclaration(SBDeclaration rhs) -> SBDeclaration\n"
		""},
	 { "delete_SBDeclaration", _wrap_delete_SBDeclaration, METH_O, "delete_SBDeclaration(SBDeclaration self)"},
	 { "SBDeclaration___nonzero__", _wrap_SBDeclaration___nonzero__, METH_O, "SBDeclaration___nonzero__(SBDeclaration self) -> bool"},
	 { "SBDeclaration_IsValid", _wrap_SBDeclaration_IsValid, METH_O, "SBDeclaration_IsValid(SBDeclaration self) -> bool"},
	 { "SBDeclaration_GetFileSpec", _wrap_SBDeclaration_GetFileSpec, METH_O, "SBDeclaration_GetFileSpec(SBDeclaration self) -> SBFileSpec"},
	 { "SBDeclaration_GetLine", _wrap_SBDeclaration_GetLine, METH_O, "SBDeclaration_GetLine(SBDeclaration self) -> uint32_t"},
	 { "SBDeclaration_GetColumn", _wrap_SBDeclaration_GetColumn, METH_O, "SBDeclaration_GetColumn(SBDeclaration self) -> uint32_t"},
	 { "SBDeclaration_SetFileSpec", _wrap_SBDeclaration_SetFileSpec, METH_VARARGS, "SBDeclaration_SetFileSpec(SBDeclaration self, SBFileSpec filespec)"},
	 { "SBDeclaration_SetLine", _wrap_SBDeclaration_SetLine, METH_VARARGS, "SBDeclaration_SetLine(SBDeclaration self, uint32_t line)"},
	 { "SBDeclaration_SetColumn", _wrap_SBDeclaration_SetColumn, METH_VARARGS, "SBDeclaration_SetColumn(SBDeclaration self, uint32_t column)"},
	 { "SBDeclaration___eq__", _wrap_SBDeclaration___eq__, METH_VARARGS, "SBDeclaration___eq__(SBDeclaration self, SBDeclaration rhs) -> bool"},
	 { "SBDeclaration___ne__", _wrap_SBDeclaration___ne__, METH_VARARGS, "SBDeclaration___ne__(SBDeclaration self, SBDeclaration rhs) -> bool"},
	 { "SBDeclaration_GetDescription", _wrap_SBDeclaration_GetDescription, METH_VARARGS, "SBDeclaration_GetDescription(SBDeclaration self, SBStream description) -> bool"},
	 { "SBDeclaration___repr__", _wrap_SBDeclaration___repr__, METH_O, "SBDeclaration___repr__(SBDeclaration self) -> std::string"},
	 { "SBDeclaration_swigregister", SBDeclaration_swigregister, METH_O, NULL},
	 { "SBDeclaration_swiginit", SBDeclaration_swiginit, METH_VARARGS, NULL},
	 { "new_SBError", _wrap_new_SBError, METH_VARARGS, "\n"
		"SBError()\n"
		"SBError(SBError rhs)\n"
		"new_SBError(char const * message) -> SBError\n"
		""},
	 { "delete_SBError", _wrap_delete_SBError, METH_O, "delete_SBError(SBError self)"},
	 { "SBError_GetCString", _wrap_SBError_GetCString, METH_O, "\n"
		"Get the error string as a NULL terminated UTF8 c-string.\n"
		"\n"
		"This SBError object owns the returned string and this object must be kept\n"
		"around long enough to use the returned string.\n"
		""},
	 { "SBError_Clear", _wrap_SBError_Clear, METH_O, "SBError_Clear(SBError self)"},
	 { "SBError_Fail", _wrap_SBError_Fail, METH_O, "SBError_Fail(SBError self) -> bool"},
	 { "SBError_Success", _wrap_SBError_Success, METH_O, "SBError_Success(SBError self) -> bool"},
	 { "SBError_GetError", _wrap_SBError_GetError, METH_O, "Get the error code."},
	 { "SBError_GetErrorData", _wrap_SBError_GetErrorData, METH_O, "\n"
		"Get the error in machine-readable form. Particularly useful for\n"
		"compiler diagnostics.\n"
		""},
	 { "SBError_GetType", _wrap_SBError_GetType, METH_O, "SBError_GetType(SBError self) -> lldb::ErrorType"},
	 { "SBError_SetError", _wrap_SBError_SetError, METH_VARARGS, "SBError_SetError(SBError self, uint32_t err, lldb::ErrorType type)"},
	 { "SBError_SetErrorToErrno", _wrap_SBError_SetErrorToErrno, METH_O, "SBError_SetErrorToErrno(SBError self)"},
	 { "SBError_SetErrorToGenericError", _wrap_SBError_SetErrorToGenericError, METH_O, "SBError_SetErrorToGenericError(SBError self)"},
	 { "SBError_SetErrorString", _wrap_SBError_SetErrorString, METH_VARARGS, "SBError_SetErrorString(SBError self, char const * err_str)"},
	 { "SBError_SetErrorStringWithFormat", _wrap_SBError_SetErrorStringWithFormat, METH_VARARGS, "SBError_SetErrorStringWithFormat(SBError self, char const * format, char * str1=None, char * str2=None, char * str3=None) -> int"},
	 { "SBError___nonzero__", _wrap_SBError___nonzero__, METH_O, "SBError___nonzero__(SBError self) -> bool"},
	 { "SBError_IsValid", _wrap_SBError_IsValid, METH_O, "\n"
		"Returns ``true`` if this object contains an underlying ``Status``\n"
		"object.\n"
		"\n"
		"That object may represent a success or a failure. When ``IsValid`` returns\n"
		"``false``, it may be the case that the ``SBError`` represents a success but\n"
		"does not contain a ``Status`` representing that success.\n"
		"\n"
		"It is safe to call ``Success`` or ``Fail`` in the case where ``IsValid``\n"
		"returns ``false``.\n"
		""},
	 { "SBError_GetDescription", _wrap_SBError_GetDescription, METH_VARARGS, "SBError_GetDescription(SBError self, SBStream description) -> bool"},
	 { "SBError___repr__", _wrap_SBError___repr__, METH_O, "SBError___repr__(SBError self) -> std::string"},
	 { "SBError_swigregister", SBError_swigregister, METH_O, NULL},
	 { "SBError_swiginit", SBError_swiginit, METH_VARARGS, NULL},
	 { "new_SBEnvironment", _wrap_new_SBEnvironment, METH_VARARGS, "\n"
		"SBEnvironment()\n"
		"new_SBEnvironment(SBEnvironment rhs) -> SBEnvironment\n"
		""},
	 { "delete_SBEnvironment", _wrap_delete_SBEnvironment, METH_O, "delete_SBEnvironment(SBEnvironment self)"},
	 { "SBEnvironment_Get", _wrap_SBEnvironment_Get, METH_VARARGS, "\n"
		"Return the value of a given environment variable.\n"
		"\n"
		":param [in]: name\n"
		"        The name of the environment variable.\n"
		"\n"
		":rtype: string\n"
		":return: \n"
		"        The value of the environment variable or null if not present.\n"
		"        If the environment variable has no value but is present, a valid\n"
		"        pointer to an empty string will be returned.\n"
		""},
	 { "SBEnvironment_GetNumValues", _wrap_SBEnvironment_GetNumValues, METH_O, "\n"
		":rtype: int\n"
		":return: \n"
		"        The number of environment variables.\n"
		""},
	 { "SBEnvironment_GetNameAtIndex", _wrap_SBEnvironment_GetNameAtIndex, METH_VARARGS, "\n"
		"Return the name of the environment variable at a given index from the\n"
		"internal list of environment variables.\n"
		"\n"
		":param [in]: index\n"
		"        The index of the environment variable in the internal list.\n"
		"\n"
		":rtype: string\n"
		":return: \n"
		"        The name at the given index or null if the index is invalid.\n"
		""},
	 { "SBEnvironment_GetValueAtIndex", _wrap_SBEnvironment_GetValueAtIndex, METH_VARARGS, "\n"
		"Return the value of the environment variable at a given index from the\n"
		"internal list of environment variables.\n"
		"\n"
		":param [in]: index\n"
		"        The index of the environment variable in the internal list.\n"
		"\n"
		":rtype: string\n"
		":return: \n"
		"        The value at the given index or null if the index is invalid.\n"
		"        If the environment variable has no value but is present, a valid\n"
		"        pointer to an empty string will be returned.\n"
		""},
	 { "SBEnvironment_GetEntries", _wrap_SBEnvironment_GetEntries, METH_O, "\n"
		"Return all environment variables contained in this object. Each variable\n"
		"is returned as a string with the following format\n"
		"    name=value\n"
		"\n"
		":rtype: :py:class:`SBStringList`\n"
		":return: \n"
		"        Return an lldb::SBStringList object with the environment variables.\n"
		""},
	 { "SBEnvironment_PutEntry", _wrap_SBEnvironment_PutEntry, METH_VARARGS, "\n"
		"Add or replace an existing environment variable. The input must be a\n"
		"string with the format\n"
		"    name=value\n"
		"\n"
		":param [in]: name_and_value\n"
		"        The entry to set which conforms to the format mentioned above.\n"
		""},
	 { "SBEnvironment_SetEntries", _wrap_SBEnvironment_SetEntries, METH_VARARGS, "\n"
		"Update this object with the given environment variables. The input is a\n"
		"list of entries with the same format required by SBEnvironment::PutEntry.\n"
		"\n"
		"If append is false, the provided environment will replace the existing\n"
		"environment. Otherwise, existing values will be updated of left untouched\n"
		"accordingly.\n"
		"\n"
		":param [in]: entries\n"
		"        The environment variable entries.\n"
		"\n"
		":param [in]: append\n"
		"        Flag that controls whether to replace the existing environment.\n"
		""},
	 { "SBEnvironment_Set", _wrap_SBEnvironment_Set, METH_VARARGS, "\n"
		"Set the value of a given environment variable.\n"
		"If the variable exists, its value is updated only if overwrite is true.\n"
		"\n"
		":param [in]: name\n"
		"        The name of the environment variable to set.\n"
		"\n"
		":param [in]: value\n"
		"        The value of the environment variable to set.\n"
		"\n"
		":param [in]: overwrite\n"
		"        Flag that indicates whether to overwrite an existing environment\n"
		"        variable.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"        Return whether the variable was added or modified.\n"
		""},
	 { "SBEnvironment_Unset", _wrap_SBEnvironment_Unset, METH_VARARGS, "\n"
		"Unset an environment variable if exists.\n"
		"\n"
		":param [in]: name\n"
		"        The name of the environment variable to unset.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"        Return whether a variable was actually unset.\n"
		""},
	 { "SBEnvironment_Clear", _wrap_SBEnvironment_Clear, METH_O, "Delete all the environment variables."},
	 { "SBEnvironment_swigregister", SBEnvironment_swigregister, METH_O, NULL},
	 { "SBEnvironment_swiginit", SBEnvironment_swiginit, METH_VARARGS, NULL},
	 { "new_SBEvent", _wrap_new_SBEvent, METH_VARARGS, "__init__(self, int type, str data) -> SBEvent (make an event that contains a C string)__init__(self, int type, str data) -> SBEvent (make an event that contains a C string)__init__(self, int type, str data) -> SBEvent (make an event that contains a C string)"},
	 { "delete_SBEvent", _wrap_delete_SBEvent, METH_O, "delete_SBEvent(SBEvent self)"},
	 { "SBEvent___nonzero__", _wrap_SBEvent___nonzero__, METH_O, "SBEvent___nonzero__(SBEvent self) -> bool"},
	 { "SBEvent_IsValid", _wrap_SBEvent_IsValid, METH_O, "SBEvent_IsValid(SBEvent self) -> bool"},
	 { "SBEvent_GetDataFlavor", _wrap_SBEvent_GetDataFlavor, METH_O, "SBEvent_GetDataFlavor(SBEvent self) -> char const *"},
	 { "SBEvent_GetType", _wrap_SBEvent_GetType, METH_O, "SBEvent_GetType(SBEvent self) -> uint32_t"},
	 { "SBEvent_GetBroadcaster", _wrap_SBEvent_GetBroadcaster, METH_O, "SBEvent_GetBroadcaster(SBEvent self) -> SBBroadcaster"},
	 { "SBEvent_GetBroadcasterClass", _wrap_SBEvent_GetBroadcasterClass, METH_O, "SBEvent_GetBroadcasterClass(SBEvent self) -> char const *"},
	 { "SBEvent_BroadcasterMatchesRef", _wrap_SBEvent_BroadcasterMatchesRef, METH_VARARGS, "SBEvent_BroadcasterMatchesRef(SBEvent self, SBBroadcaster broadcaster) -> bool"},
	 { "SBEvent_Clear", _wrap_SBEvent_Clear, METH_O, "SBEvent_Clear(SBEvent self)"},
	 { "SBEvent_GetCStringFromEvent", _wrap_SBEvent_GetCStringFromEvent, METH_O, "SBEvent_GetCStringFromEvent(SBEvent event) -> char const *"},
	 { "SBEvent_GetDescription", _wrap_SBEvent_GetDescription, METH_VARARGS, "\n"
		"SBEvent_GetDescription(SBEvent self, SBStream description) -> bool\n"
		"SBEvent_GetDescription(SBEvent self, SBStream description) -> bool\n"
		""},
	 { "SBEvent_swigregister", SBEvent_swigregister, METH_O, NULL},
	 { "SBEvent_swiginit", SBEvent_swiginit, METH_VARARGS, NULL},
	 { "new_SBExecutionContext", _wrap_new_SBExecutionContext, METH_VARARGS, "\n"
		"SBExecutionContext()\n"
		"SBExecutionContext(SBExecutionContext rhs)\n"
		"SBExecutionContext(SBTarget target)\n"
		"SBExecutionContext(SBProcess process)\n"
		"SBExecutionContext(SBThread thread)\n"
		"new_SBExecutionContext(SBFrame frame) -> SBExecutionContext\n"
		""},
	 { "delete_SBExecutionContext", _wrap_delete_SBExecutionContext, METH_O, "delete_SBExecutionContext(SBExecutionContext self)"},
	 { "SBExecutionContext_GetTarget", _wrap_SBExecutionContext_GetTarget, METH_O, "SBExecutionContext_GetTarget(SBExecutionContext self) -> SBTarget"},
	 { "SBExecutionContext_GetProcess", _wrap_SBExecutionContext_GetProcess, METH_O, "SBExecutionContext_GetProcess(SBExecutionContext self) -> SBProcess"},
	 { "SBExecutionContext_GetThread", _wrap_SBExecutionContext_GetThread, METH_O, "SBExecutionContext_GetThread(SBExecutionContext self) -> SBThread"},
	 { "SBExecutionContext_GetFrame", _wrap_SBExecutionContext_GetFrame, METH_O, "SBExecutionContext_GetFrame(SBExecutionContext self) -> SBFrame"},
	 { "SBExecutionContext_swigregister", SBExecutionContext_swigregister, METH_O, NULL},
	 { "SBExecutionContext_swiginit", SBExecutionContext_swiginit, METH_VARARGS, NULL},
	 { "new_SBExpressionOptions", _wrap_new_SBExpressionOptions, METH_VARARGS, "\n"
		"SBExpressionOptions()\n"
		"new_SBExpressionOptions(SBExpressionOptions rhs) -> SBExpressionOptions\n"
		""},
	 { "delete_SBExpressionOptions", _wrap_delete_SBExpressionOptions, METH_O, "delete_SBExpressionOptions(SBExpressionOptions self)"},
	 { "SBExpressionOptions_GetCoerceResultToId", _wrap_SBExpressionOptions_GetCoerceResultToId, METH_O, "SBExpressionOptions_GetCoerceResultToId(SBExpressionOptions self) -> bool"},
	 { "SBExpressionOptions_SetCoerceResultToId", _wrap_SBExpressionOptions_SetCoerceResultToId, METH_VARARGS, "\n"
		"SBExpressionOptions_SetCoerceResultToId(SBExpressionOptions self, bool coerce=True)\n"
		"Sets whether to coerce the expression result to ObjC id type after evaluation.\n"
		""},
	 { "SBExpressionOptions_GetUnwindOnError", _wrap_SBExpressionOptions_GetUnwindOnError, METH_O, "SBExpressionOptions_GetUnwindOnError(SBExpressionOptions self) -> bool"},
	 { "SBExpressionOptions_SetUnwindOnError", _wrap_SBExpressionOptions_SetUnwindOnError, METH_VARARGS, "\n"
		"SBExpressionOptions_SetUnwindOnError(SBExpressionOptions self, bool unwind=True)\n"
		"Sets whether to unwind the expression stack on error.\n"
		""},
	 { "SBExpressionOptions_GetIgnoreBreakpoints", _wrap_SBExpressionOptions_GetIgnoreBreakpoints, METH_O, "SBExpressionOptions_GetIgnoreBreakpoints(SBExpressionOptions self) -> bool"},
	 { "SBExpressionOptions_SetIgnoreBreakpoints", _wrap_SBExpressionOptions_SetIgnoreBreakpoints, METH_VARARGS, "\n"
		"SBExpressionOptions_SetIgnoreBreakpoints(SBExpressionOptions self, bool ignore=True)\n"
		"Sets whether to ignore breakpoint hits while running expressions.\n"
		""},
	 { "SBExpressionOptions_GetFetchDynamicValue", _wrap_SBExpressionOptions_GetFetchDynamicValue, METH_O, "SBExpressionOptions_GetFetchDynamicValue(SBExpressionOptions self) -> lldb::DynamicValueType"},
	 { "SBExpressionOptions_SetFetchDynamicValue", _wrap_SBExpressionOptions_SetFetchDynamicValue, METH_VARARGS, "\n"
		"SBExpressionOptions_SetFetchDynamicValue(SBExpressionOptions self, lldb::DynamicValueType dynamic=eDynamicCanRunTarget)\n"
		"Sets whether to cast the expression result to its dynamic type.\n"
		""},
	 { "SBExpressionOptions_GetTimeoutInMicroSeconds", _wrap_SBExpressionOptions_GetTimeoutInMicroSeconds, METH_O, "SBExpressionOptions_GetTimeoutInMicroSeconds(SBExpressionOptions self) -> uint32_t"},
	 { "SBExpressionOptions_SetTimeoutInMicroSeconds", _wrap_SBExpressionOptions_SetTimeoutInMicroSeconds, METH_VARARGS, "\n"
		"SBExpressionOptions_SetTimeoutInMicroSeconds(SBExpressionOptions self, uint32_t timeout=0)\n"
		"Sets the timeout in microseconds to run the expression for. If try all threads is set to true and the expression doesn't complete within the specified timeout, all threads will be resumed for the same timeout to see if the expression will finish.\n"
		""},
	 { "SBExpressionOptions_GetOneThreadTimeoutInMicroSeconds", _wrap_SBExpressionOptions_GetOneThreadTimeoutInMicroSeconds, METH_O, "SBExpressionOptions_GetOneThreadTimeoutInMicroSeconds(SBExpressionOptions self) -> uint32_t"},
	 { "SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds", _wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds, METH_VARARGS, "\n"
		"SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds(SBExpressionOptions self, uint32_t timeout=0)\n"
		"Sets the timeout in microseconds to run the expression on one thread before either timing out or trying all threads.\n"
		""},
	 { "SBExpressionOptions_GetTryAllThreads", _wrap_SBExpressionOptions_GetTryAllThreads, METH_O, "SBExpressionOptions_GetTryAllThreads(SBExpressionOptions self) -> bool"},
	 { "SBExpressionOptions_SetTryAllThreads", _wrap_SBExpressionOptions_SetTryAllThreads, METH_VARARGS, "\n"
		"SBExpressionOptions_SetTryAllThreads(SBExpressionOptions self, bool run_others=True)\n"
		"Sets whether to run all threads if the expression does not complete on one thread.\n"
		""},
	 { "SBExpressionOptions_GetStopOthers", _wrap_SBExpressionOptions_GetStopOthers, METH_O, "SBExpressionOptions_GetStopOthers(SBExpressionOptions self) -> bool"},
	 { "SBExpressionOptions_SetStopOthers", _wrap_SBExpressionOptions_SetStopOthers, METH_VARARGS, "\n"
		"SBExpressionOptions_SetStopOthers(SBExpressionOptions self, bool stop_others=True)\n"
		"Sets whether to stop other threads at all while running expressions.  If false, TryAllThreads does nothing.\n"
		""},
	 { "SBExpressionOptions_GetTrapExceptions", _wrap_SBExpressionOptions_GetTrapExceptions, METH_O, "SBExpressionOptions_GetTrapExceptions(SBExpressionOptions self) -> bool"},
	 { "SBExpressionOptions_SetTrapExceptions", _wrap_SBExpressionOptions_SetTrapExceptions, METH_VARARGS, "\n"
		"SBExpressionOptions_SetTrapExceptions(SBExpressionOptions self, bool trap_exceptions=True)\n"
		"Sets whether to abort expression evaluation if an exception is thrown while executing.  Don't set this to false unless you know the function you are calling traps all exceptions itself.\n"
		""},
	 { "SBExpressionOptions_SetLanguage", _wrap_SBExpressionOptions_SetLanguage, METH_VARARGS, "\n"
		"SBExpressionOptions_SetLanguage(SBExpressionOptions self, lldb::LanguageType language)\n"
		"SBExpressionOptions_SetLanguage(SBExpressionOptions self, lldb::SBSourceLanguageName name, uint32_t version)\n"
		"Sets the language that LLDB should assume the expression is written in\n"
		""},
	 { "SBExpressionOptions_GetGenerateDebugInfo", _wrap_SBExpressionOptions_GetGenerateDebugInfo, METH_O, "SBExpressionOptions_GetGenerateDebugInfo(SBExpressionOptions self) -> bool"},
	 { "SBExpressionOptions_SetGenerateDebugInfo", _wrap_SBExpressionOptions_SetGenerateDebugInfo, METH_VARARGS, "\n"
		"SBExpressionOptions_SetGenerateDebugInfo(SBExpressionOptions self, bool b=True)\n"
		"Sets whether to generate debug information for the expression and also controls if a SBModule is generated.\n"
		""},
	 { "SBExpressionOptions_GetSuppressPersistentResult", _wrap_SBExpressionOptions_GetSuppressPersistentResult, METH_O, "SBExpressionOptions_GetSuppressPersistentResult(SBExpressionOptions self) -> bool"},
	 { "SBExpressionOptions_SetSuppressPersistentResult", _wrap_SBExpressionOptions_SetSuppressPersistentResult, METH_VARARGS, "\n"
		"SBExpressionOptions_SetSuppressPersistentResult(SBExpressionOptions self, bool b=False)\n"
		"Sets whether to produce a persistent result that can be used in future expressions.\n"
		""},
	 { "SBExpressionOptions_GetPrefix", _wrap_SBExpressionOptions_GetPrefix, METH_O, "\n"
		"SBExpressionOptions_GetPrefix(SBExpressionOptions self) -> char const *\n"
		"Gets the prefix to use for this expression.\n"
		""},
	 { "SBExpressionOptions_SetPrefix", _wrap_SBExpressionOptions_SetPrefix, METH_VARARGS, "\n"
		"SBExpressionOptions_SetPrefix(SBExpressionOptions self, char const * prefix)\n"
		"Sets the prefix to use for this expression. This prefix gets inserted after the 'target.expr-prefix' prefix contents, but before the wrapped expression function body.\n"
		""},
	 { "SBExpressionOptions_SetAutoApplyFixIts", _wrap_SBExpressionOptions_SetAutoApplyFixIts, METH_VARARGS, "\n"
		"SBExpressionOptions_SetAutoApplyFixIts(SBExpressionOptions self, bool b=True)\n"
		"Sets whether to auto-apply fix-it hints to the expression being evaluated.\n"
		""},
	 { "SBExpressionOptions_GetAutoApplyFixIts", _wrap_SBExpressionOptions_GetAutoApplyFixIts, METH_O, "\n"
		"SBExpressionOptions_GetAutoApplyFixIts(SBExpressionOptions self) -> bool\n"
		"Gets whether to auto-apply fix-it hints to an expression.\n"
		""},
	 { "SBExpressionOptions_SetRetriesWithFixIts", _wrap_SBExpressionOptions_SetRetriesWithFixIts, METH_VARARGS, "\n"
		"SBExpressionOptions_SetRetriesWithFixIts(SBExpressionOptions self, uint64_t retries)\n"
		"Sets how often LLDB should retry applying fix-its to an expression.\n"
		""},
	 { "SBExpressionOptions_GetRetriesWithFixIts", _wrap_SBExpressionOptions_GetRetriesWithFixIts, METH_O, "\n"
		"SBExpressionOptions_GetRetriesWithFixIts(SBExpressionOptions self) -> uint64_t\n"
		"Gets how often LLDB will retry applying fix-its to an expression.\n"
		""},
	 { "SBExpressionOptions_GetTopLevel", _wrap_SBExpressionOptions_GetTopLevel, METH_O, "SBExpressionOptions_GetTopLevel(SBExpressionOptions self) -> bool"},
	 { "SBExpressionOptions_SetTopLevel", _wrap_SBExpressionOptions_SetTopLevel, METH_VARARGS, "SBExpressionOptions_SetTopLevel(SBExpressionOptions self, bool b=True)"},
	 { "SBExpressionOptions_GetAllowJIT", _wrap_SBExpressionOptions_GetAllowJIT, METH_O, "\n"
		"SBExpressionOptions_GetAllowJIT(SBExpressionOptions self) -> bool\n"
		"Gets whether to JIT an expression if it cannot be interpreted.\n"
		""},
	 { "SBExpressionOptions_SetAllowJIT", _wrap_SBExpressionOptions_SetAllowJIT, METH_VARARGS, "\n"
		"SBExpressionOptions_SetAllowJIT(SBExpressionOptions self, bool allow)\n"
		"Sets whether to JIT an expression if it cannot be interpreted.\n"
		""},
	 { "SBExpressionOptions_swigregister", SBExpressionOptions_swigregister, METH_O, NULL},
	 { "SBExpressionOptions_swiginit", SBExpressionOptions_swiginit, METH_VARARGS, NULL},
	 { "new_SBFile", _wrap_new_SBFile, METH_VARARGS, "\n"
		"SBFile()\n"
		"SBFile(lldb::FileSP file_sp)\n"
		"new_SBFile(int fd, char const * mode, bool transfer_ownership) -> SBFile\n"
		"initialize a SBFile from a python file object\n"
		""},
	 { "delete_SBFile", _wrap_delete_SBFile, METH_O, "delete_SBFile(SBFile self)"},
	 { "SBFile_Read", _wrap_SBFile_Read, METH_VARARGS, "Read(buffer) -> SBError, bytes_read"},
	 { "SBFile_Write", _wrap_SBFile_Write, METH_VARARGS, "Write(buffer) -> SBError, written_read"},
	 { "SBFile_Flush", _wrap_SBFile_Flush, METH_O, "SBFile_Flush(SBFile self) -> SBError"},
	 { "SBFile_IsValid", _wrap_SBFile_IsValid, METH_O, "SBFile_IsValid(SBFile self) -> bool"},
	 { "SBFile_Close", _wrap_SBFile_Close, METH_O, "SBFile_Close(SBFile self) -> SBError"},
	 { "SBFile___nonzero__", _wrap_SBFile___nonzero__, METH_O, "SBFile___nonzero__(SBFile self) -> bool"},
	 { "SBFile_GetFile", _wrap_SBFile_GetFile, METH_O, "\n"
		"SBFile_GetFile(SBFile self) -> lldb::FileSP\n"
		"\n"
		"    Convert this SBFile into a python io.IOBase file object.\n"
		"\n"
		"    If the SBFile is itself a wrapper around a python file object,\n"
		"    this will return that original object.\n"
		"\n"
		"    The file returned from here should be considered borrowed,\n"
		"    in the sense that you may read and write to it, and flush it,\n"
		"    etc, but you should not close it.   If you want to close the\n"
		"    SBFile, call SBFile.Close().\n"
		"\n"
		"    If there is no underlying python file to unwrap, GetFile will\n"
		"    use the file descriptor, if available to create a new python\n"
		"    file object using ``open(fd, mode=..., closefd=False)``\n"
		"\n"
		""},
	 { "SBFile_MakeBorrowed", _wrap_SBFile_MakeBorrowed, METH_O, "SBFile_MakeBorrowed(lldb::FileSP BORROWED) -> SBFile"},
	 { "SBFile_MakeForcingIOMethods", _wrap_SBFile_MakeForcingIOMethods, METH_O, "SBFile_MakeForcingIOMethods(lldb::FileSP FORCE_IO_METHODS) -> SBFile"},
	 { "SBFile_MakeBorrowedForcingIOMethods", _wrap_SBFile_MakeBorrowedForcingIOMethods, METH_O, "SBFile_MakeBorrowedForcingIOMethods(lldb::FileSP BORROWED_FORCE_IO_METHODS) -> SBFile"},
	 { "SBFile_swigregister", SBFile_swigregister, METH_O, NULL},
	 { "SBFile_swiginit", SBFile_swiginit, METH_VARARGS, NULL},
	 { "new_SBFileSpec", _wrap_new_SBFileSpec, METH_VARARGS, "\n"
		"SBFileSpec()\n"
		"SBFileSpec(SBFileSpec rhs)\n"
		"SBFileSpec(char const * path)\n"
		"new_SBFileSpec(char const * path, bool resolve) -> SBFileSpec\n"
		""},
	 { "delete_SBFileSpec", _wrap_delete_SBFileSpec, METH_O, "delete_SBFileSpec(SBFileSpec self)"},
	 { "SBFileSpec___nonzero__", _wrap_SBFileSpec___nonzero__, METH_O, "SBFileSpec___nonzero__(SBFileSpec self) -> bool"},
	 { "SBFileSpec___eq__", _wrap_SBFileSpec___eq__, METH_VARARGS, "SBFileSpec___eq__(SBFileSpec self, SBFileSpec rhs) -> bool"},
	 { "SBFileSpec___ne__", _wrap_SBFileSpec___ne__, METH_VARARGS, "SBFileSpec___ne__(SBFileSpec self, SBFileSpec rhs) -> bool"},
	 { "SBFileSpec_IsValid", _wrap_SBFileSpec_IsValid, METH_O, "SBFileSpec_IsValid(SBFileSpec self) -> bool"},
	 { "SBFileSpec_Exists", _wrap_SBFileSpec_Exists, METH_O, "SBFileSpec_Exists(SBFileSpec self) -> bool"},
	 { "SBFileSpec_ResolveExecutableLocation", _wrap_SBFileSpec_ResolveExecutableLocation, METH_O, "SBFileSpec_ResolveExecutableLocation(SBFileSpec self) -> bool"},
	 { "SBFileSpec_GetFilename", _wrap_SBFileSpec_GetFilename, METH_O, "SBFileSpec_GetFilename(SBFileSpec self) -> char const *"},
	 { "SBFileSpec_GetDirectory", _wrap_SBFileSpec_GetDirectory, METH_O, "SBFileSpec_GetDirectory(SBFileSpec self) -> char const *"},
	 { "SBFileSpec_SetFilename", _wrap_SBFileSpec_SetFilename, METH_VARARGS, "SBFileSpec_SetFilename(SBFileSpec self, char const * filename)"},
	 { "SBFileSpec_SetDirectory", _wrap_SBFileSpec_SetDirectory, METH_VARARGS, "SBFileSpec_SetDirectory(SBFileSpec self, char const * directory)"},
	 { "SBFileSpec_GetPath", _wrap_SBFileSpec_GetPath, METH_VARARGS, "SBFileSpec_GetPath(SBFileSpec self, char * dst_path) -> uint32_t"},
	 { "SBFileSpec_ResolvePath", _wrap_SBFileSpec_ResolvePath, METH_VARARGS, "SBFileSpec_ResolvePath(char const * src_path, char * dst_path) -> int"},
	 { "SBFileSpec_GetDescription", _wrap_SBFileSpec_GetDescription, METH_VARARGS, "SBFileSpec_GetDescription(SBFileSpec self, SBStream description) -> bool"},
	 { "SBFileSpec_AppendPathComponent", _wrap_SBFileSpec_AppendPathComponent, METH_VARARGS, "SBFileSpec_AppendPathComponent(SBFileSpec self, char const * file_or_directory)"},
	 { "SBFileSpec___repr__", _wrap_SBFileSpec___repr__, METH_O, "SBFileSpec___repr__(SBFileSpec self) -> std::string"},
	 { "SBFileSpec_swigregister", SBFileSpec_swigregister, METH_O, NULL},
	 { "SBFileSpec_swiginit", SBFileSpec_swiginit, METH_VARARGS, NULL},
	 { "new_SBFileSpecList", _wrap_new_SBFileSpecList, METH_VARARGS, "\n"
		"SBFileSpecList()\n"
		"new_SBFileSpecList(SBFileSpecList rhs) -> SBFileSpecList\n"
		""},
	 { "delete_SBFileSpecList", _wrap_delete_SBFileSpecList, METH_O, "delete_SBFileSpecList(SBFileSpecList self)"},
	 { "SBFileSpecList_GetSize", _wrap_SBFileSpecList_GetSize, METH_O, "SBFileSpecList_GetSize(SBFileSpecList self) -> uint32_t"},
	 { "SBFileSpecList_GetDescription", _wrap_SBFileSpecList_GetDescription, METH_VARARGS, "SBFileSpecList_GetDescription(SBFileSpecList self, SBStream description) -> bool"},
	 { "SBFileSpecList_Append", _wrap_SBFileSpecList_Append, METH_VARARGS, "SBFileSpecList_Append(SBFileSpecList self, SBFileSpec sb_file)"},
	 { "SBFileSpecList_AppendIfUnique", _wrap_SBFileSpecList_AppendIfUnique, METH_VARARGS, "SBFileSpecList_AppendIfUnique(SBFileSpecList self, SBFileSpec sb_file) -> bool"},
	 { "SBFileSpecList_Clear", _wrap_SBFileSpecList_Clear, METH_O, "SBFileSpecList_Clear(SBFileSpecList self)"},
	 { "SBFileSpecList_FindFileIndex", _wrap_SBFileSpecList_FindFileIndex, METH_VARARGS, "SBFileSpecList_FindFileIndex(SBFileSpecList self, uint32_t idx, SBFileSpec sb_file, bool full) -> uint32_t"},
	 { "SBFileSpecList_GetFileSpecAtIndex", _wrap_SBFileSpecList_GetFileSpecAtIndex, METH_VARARGS, "SBFileSpecList_GetFileSpecAtIndex(SBFileSpecList self, uint32_t idx) -> SBFileSpec"},
	 { "SBFileSpecList___repr__", _wrap_SBFileSpecList___repr__, METH_O, "SBFileSpecList___repr__(SBFileSpecList self) -> std::string"},
	 { "SBFileSpecList_swigregister", SBFileSpecList_swigregister, METH_O, NULL},
	 { "SBFileSpecList_swiginit", SBFileSpecList_swiginit, METH_VARARGS, NULL},
	 { "new_SBFormat", _wrap_new_SBFormat, METH_VARARGS, "\n"
		"SBFormat()\n"
		"SBFormat(char const * format, SBError error)\n"
		"new_SBFormat(SBFormat rhs) -> SBFormat\n"
		""},
	 { "delete_SBFormat", _wrap_delete_SBFormat, METH_O, "delete_SBFormat(SBFormat self)"},
	 { "SBFormat___nonzero__", _wrap_SBFormat___nonzero__, METH_O, "\n"
		":rtype: boolean\n"
		":return: \n"
		"      **true** if and only if this object is valid and can be used for\n"
		"      formatting.\n"
		""},
	 { "SBFormat_swigregister", SBFormat_swigregister, METH_O, NULL},
	 { "SBFormat_swiginit", SBFormat_swiginit, METH_VARARGS, NULL},
	 { "new_SBFrame", _wrap_new_SBFrame, METH_VARARGS, "\n"
		"SBFrame()\n"
		"new_SBFrame(SBFrame rhs) -> SBFrame\n"
		""},
	 { "delete_SBFrame", _wrap_delete_SBFrame, METH_O, "delete_SBFrame(SBFrame self)"},
	 { "SBFrame_IsEqual", _wrap_SBFrame_IsEqual, METH_VARARGS, "SBFrame_IsEqual(SBFrame self, SBFrame that) -> bool"},
	 { "SBFrame___nonzero__", _wrap_SBFrame___nonzero__, METH_O, "SBFrame___nonzero__(SBFrame self) -> bool"},
	 { "SBFrame_IsValid", _wrap_SBFrame_IsValid, METH_O, "SBFrame_IsValid(SBFrame self) -> bool"},
	 { "SBFrame_GetFrameID", _wrap_SBFrame_GetFrameID, METH_O, "SBFrame_GetFrameID(SBFrame self) -> uint32_t"},
	 { "SBFrame_GetCFA", _wrap_SBFrame_GetCFA, METH_O, "\n"
		"SBFrame_GetCFA(SBFrame self) -> lldb::addr_t\n"
		"\n"
		"    Get the Canonical Frame Address for this stack frame.\n"
		"    This is the DWARF standard's definition of a CFA, a stack address\n"
		"    that remains constant throughout the lifetime of the function.\n"
		"    Returns an lldb::addr_t stack address, or LLDB_INVALID_ADDRESS if\n"
		"    the CFA cannot be determined.\n"
		""},
	 { "SBFrame_GetPC", _wrap_SBFrame_GetPC, METH_O, "SBFrame_GetPC(SBFrame self) -> lldb::addr_t"},
	 { "SBFrame_SetPC", _wrap_SBFrame_SetPC, METH_VARARGS, "SBFrame_SetPC(SBFrame self, lldb::addr_t new_pc) -> bool"},
	 { "SBFrame_GetSP", _wrap_SBFrame_GetSP, METH_O, "SBFrame_GetSP(SBFrame self) -> lldb::addr_t"},
	 { "SBFrame_GetFP", _wrap_SBFrame_GetFP, METH_O, "SBFrame_GetFP(SBFrame self) -> lldb::addr_t"},
	 { "SBFrame_GetPCAddress", _wrap_SBFrame_GetPCAddress, METH_O, "SBFrame_GetPCAddress(SBFrame self) -> SBAddress"},
	 { "SBFrame_GetSymbolContext", _wrap_SBFrame_GetSymbolContext, METH_VARARGS, "SBFrame_GetSymbolContext(SBFrame self, uint32_t resolve_scope) -> SBSymbolContext"},
	 { "SBFrame_GetModule", _wrap_SBFrame_GetModule, METH_O, "SBFrame_GetModule(SBFrame self) -> SBModule"},
	 { "SBFrame_GetCompileUnit", _wrap_SBFrame_GetCompileUnit, METH_O, "SBFrame_GetCompileUnit(SBFrame self) -> SBCompileUnit"},
	 { "SBFrame_GetFunction", _wrap_SBFrame_GetFunction, METH_O, "SBFrame_GetFunction(SBFrame self) -> SBFunction"},
	 { "SBFrame_GetSymbol", _wrap_SBFrame_GetSymbol, METH_O, "SBFrame_GetSymbol(SBFrame self) -> SBSymbol"},
	 { "SBFrame_GetBlock", _wrap_SBFrame_GetBlock, METH_O, "\n"
		"SBFrame_GetBlock(SBFrame self) -> SBBlock\n"
		"\n"
		"    Gets the deepest block that contains the frame PC.\n"
		"\n"
		"    See also GetFrameBlock().\n"
		""},
	 { "SBFrame_GetDisplayFunctionName", _wrap_SBFrame_GetDisplayFunctionName, METH_O, "SBFrame_GetDisplayFunctionName(SBFrame self) -> char const *"},
	 { "SBFrame_GetFunctionName", _wrap_SBFrame_GetFunctionName, METH_VARARGS, "\n"
		"SBFrame_GetFunctionName(SBFrame self) -> char const\n"
		"SBFrame_GetFunctionName(SBFrame self) -> char const *\n"
		"\n"
		"    Get the appropriate function name for this frame. Inlined functions in\n"
		"    LLDB are represented by Blocks that have inlined function information, so\n"
		"    just looking at the SBFunction or SBSymbol for a frame isn't enough.\n"
		"    This function will return the appropriate function, symbol or inlined\n"
		"    function name for the frame.\n"
		"\n"
		"    This function returns:\n"
		"    - the name of the inlined function (if there is one)\n"
		"    - the name of the concrete function (if there is one)\n"
		"    - the name of the symbol (if there is one)\n"
		"    - NULL\n"
		"\n"
		"    See also IsInlined().\n"
		""},
	 { "SBFrame_GuessLanguage", _wrap_SBFrame_GuessLanguage, METH_O, "\n"
		"SBFrame_GuessLanguage(SBFrame self) -> lldb::LanguageType\n"
		"\n"
		"    Returns the language of the frame's SBFunction, or if there.\n"
		"    is no SBFunction, guess the language from the mangled name.\n"
		"    .\n"
		""},
	 { "SBFrame_IsInlined", _wrap_SBFrame_IsInlined, METH_VARARGS, "\n"
		"SBFrame_IsInlined(SBFrame self) -> bool\n"
		"SBFrame_IsInlined(SBFrame self) -> bool\n"
		"\n"
		"    Return true if this frame represents an inlined function.\n"
		"\n"
		"    See also GetFunctionName().\n"
		""},
	 { "SBFrame_IsArtificial", _wrap_SBFrame_IsArtificial, METH_VARARGS, "\n"
		"SBFrame_IsArtificial(SBFrame self) -> bool\n"
		"SBFrame_IsArtificial(SBFrame self) -> bool\n"
		"\n"
		"    Return true if this frame is artificial (e.g a frame synthesized to\n"
		"    capture a tail call). Local variables may not be available in an artificial\n"
		"    frame.\n"
		""},
	 { "SBFrame_IsSynthetic", _wrap_SBFrame_IsSynthetic, METH_O, "SBFrame_IsSynthetic(SBFrame self) -> bool"},
	 { "SBFrame_IsHidden", _wrap_SBFrame_IsHidden, METH_O, "\n"
		"Return whether a frame recognizer decided this frame should not\n"
		"be displayes in backtraces etc.\n"
		""},
	 { "SBFrame_EvaluateExpression", _wrap_SBFrame_EvaluateExpression, METH_VARARGS, "\n"
		"SBFrame_EvaluateExpression(SBFrame self, char const * expr) -> SBValue\n"
		"SBFrame_EvaluateExpression(SBFrame self, char const * expr, lldb::DynamicValueType use_dynamic) -> SBValue\n"
		"SBFrame_EvaluateExpression(SBFrame self, char const * expr, lldb::DynamicValueType use_dynamic, bool unwind_on_error) -> SBValue\n"
		"SBFrame_EvaluateExpression(SBFrame self, char const * expr, SBExpressionOptions options) -> SBValue\n"
		"\n"
		"    The version that doesn't supply a 'use_dynamic' value will use the\n"
		"    target's default.\n"
		""},
	 { "SBFrame_GetLanguageSpecificData", _wrap_SBFrame_GetLanguageSpecificData, METH_O, "\n"
		"Language plugins can use this API to report language-specific\n"
		"runtime information about this compile unit, such as additional\n"
		"language version details or feature flags.\n"
		""},
	 { "SBFrame_GetFrameBlock", _wrap_SBFrame_GetFrameBlock, METH_O, "\n"
		"SBFrame_GetFrameBlock(SBFrame self) -> SBBlock\n"
		"\n"
		"    Gets the lexical block that defines the stack frame. Another way to think\n"
		"    of this is it will return the block that contains all of the variables\n"
		"    for a stack frame. Inlined functions are represented as SBBlock objects\n"
		"    that have inlined function information: the name of the inlined function,\n"
		"    where it was called from. The block that is returned will be the first\n"
		"    block at or above the block for the PC (SBFrame::GetBlock()) that defines\n"
		"    the scope of the frame. When a function contains no inlined functions,\n"
		"    this will be the top most lexical block that defines the function.\n"
		"    When a function has inlined functions and the PC is currently\n"
		"    in one of those inlined functions, this method will return the inlined\n"
		"    block that defines this frame. If the PC isn't currently in an inlined\n"
		"    function, the lexical block that defines the function is returned.\n"
		""},
	 { "SBFrame_GetLineEntry", _wrap_SBFrame_GetLineEntry, METH_O, "SBFrame_GetLineEntry(SBFrame self) -> SBLineEntry"},
	 { "SBFrame_GetThread", _wrap_SBFrame_GetThread, METH_O, "SBFrame_GetThread(SBFrame self) -> SBThread"},
	 { "SBFrame_Disassemble", _wrap_SBFrame_Disassemble, METH_O, "SBFrame_Disassemble(SBFrame self) -> char const *"},
	 { "SBFrame_Clear", _wrap_SBFrame_Clear, METH_O, "SBFrame_Clear(SBFrame self)"},
	 { "SBFrame___eq__", _wrap_SBFrame___eq__, METH_VARARGS, "SBFrame___eq__(SBFrame self, SBFrame rhs) -> bool"},
	 { "SBFrame___ne__", _wrap_SBFrame___ne__, METH_VARARGS, "SBFrame___ne__(SBFrame self, SBFrame rhs) -> bool"},
	 { "SBFrame_GetVariables", _wrap_SBFrame_GetVariables, METH_VARARGS, "\n"
		"SBFrame_GetVariables(SBFrame self, bool arguments, bool locals, bool statics, bool in_scope_only) -> SBValueList\n"
		"SBFrame_GetVariables(SBFrame self, bool arguments, bool locals, bool statics, bool in_scope_only, lldb::DynamicValueType use_dynamic) -> SBValueList\n"
		"SBFrame_GetVariables(SBFrame self, SBVariablesOptions options) -> SBValueList\n"
		"\n"
		"    The version that doesn't supply a 'use_dynamic' value will use the\n"
		"    target's default.\n"
		""},
	 { "SBFrame_GetRegisters", _wrap_SBFrame_GetRegisters, METH_O, "\n"
		"SBFrame_GetRegisters(SBFrame self) -> SBValueList\n"
		"\n"
		"    Returns an SBValueList which is an array of one or more register\n"
		"    sets that exist for this thread.  \n"
		"    Each SBValue in the SBValueList represents one register-set. \n"
		"    The first register-set will be the general purpose registers -- \n"
		"    the registers printed by the `register read` command-line in lldb, with \n"
		"    no additional arguments.  \n"
		"    The register-set SBValue will have a name, e.g. \n"
		"    SBFrame::GetRegisters().GetValueAtIndex(0).GetName() \n"
		"    By convention, certain stubs choose to name their general-purpose \n"
		"    register-set the 'General Purpose Registers', but that is not required.\n"
		"    A register-set SBValue will have children, one child per register \n"
		"    in the register-set.\n"
		""},
	 { "SBFrame_FindRegister", _wrap_SBFrame_FindRegister, METH_VARARGS, "SBFrame_FindRegister(SBFrame self, char const * name) -> SBValue"},
	 { "SBFrame_FindVariable", _wrap_SBFrame_FindVariable, METH_VARARGS, "\n"
		"SBFrame_FindVariable(SBFrame self, char const * var_name) -> SBValue\n"
		"SBFrame_FindVariable(SBFrame self, char const * var_name, lldb::DynamicValueType use_dynamic) -> SBValue\n"
		"\n"
		"    The version that doesn't supply a 'use_dynamic' value will use the\n"
		"    target's default.\n"
		""},
	 { "SBFrame_GetValueForVariablePath", _wrap_SBFrame_GetValueForVariablePath, METH_VARARGS, "\n"
		"SBFrame_GetValueForVariablePath(SBFrame self, char const * var_expr_cstr, lldb::DynamicValueType use_dynamic) -> SBValue\n"
		"SBFrame_GetValueForVariablePath(SBFrame self, char const * var_path) -> SBValue\n"
		"\n"
		"    Get a lldb.SBValue for a variable path.\n"
		"\n"
		"    Variable paths can include access to pointer or instance members: ::\n"
		"\n"
		"        rect_ptr->origin.y\n"
		"        pt.x\n"
		"\n"
		"    Pointer dereferences: ::\n"
		"\n"
		"        *this->foo_ptr\n"
		"        **argv\n"
		"\n"
		"    Address of: ::\n"
		"\n"
		"        &pt\n"
		"        &my_array[3].x\n"
		"\n"
		"    Array accesses and treating pointers as arrays: ::\n"
		"\n"
		"        int_array[1]\n"
		"        pt_ptr[22].x\n"
		"\n"
		"    Unlike `EvaluateExpression()` which returns :py:class:`SBValue` objects\n"
		"    with constant copies of the values at the time of evaluation,\n"
		"    the result of this function is a value that will continue to\n"
		"    track the current value of the value as execution progresses\n"
		"    in the current frame.\n"
		""},
	 { "SBFrame_FindValue", _wrap_SBFrame_FindValue, METH_VARARGS, "\n"
		"SBFrame_FindValue(SBFrame self, char const * name, lldb::ValueType value_type) -> SBValue\n"
		"SBFrame_FindValue(SBFrame self, char const * name, lldb::ValueType value_type, lldb::DynamicValueType use_dynamic) -> SBValue\n"
		"\n"
		"    Find variables, register sets, registers, or persistent variables using\n"
		"    the frame as the scope.\n"
		"\n"
		"    The version that doesn't supply a ``use_dynamic`` value will use the\n"
		"    target's default.\n"
		""},
	 { "SBFrame_GetDescription", _wrap_SBFrame_GetDescription, METH_VARARGS, "SBFrame_GetDescription(SBFrame self, SBStream description) -> bool"},
	 { "SBFrame_GetDescriptionWithFormat", _wrap_SBFrame_GetDescriptionWithFormat, METH_VARARGS, "\n"
		"Similar to *GetDescription()* but the format of the description can be\n"
		"configured via the ``format`` parameter. See\n"
		"https://lldb.llvm.org/use/formatting.html for more information on format\n"
		"strings.\n"
		"\n"
		":type format: :py:class:`SBFormat`, in\n"
		":param format:\n"
		"      The format to use for generating the description.\n"
		"\n"
		":type output: :py:class:`SBStream`, out\n"
		":param output:\n"
		"      The stream where the description will be written to.\n"
		"\n"
		":rtype: :py:class:`SBError`\n"
		":return: \n"
		"      An error object with an error message in case of failures.\n"
		""},
	 { "SBFrame___repr__", _wrap_SBFrame___repr__, METH_O, "SBFrame___repr__(SBFrame self) -> std::string"},
	 { "SBFrame_swigregister", SBFrame_swigregister, METH_O, NULL},
	 { "SBFrame_swiginit", SBFrame_swiginit, METH_VARARGS, NULL},
	 { "new_SBFrameList", _wrap_new_SBFrameList, METH_VARARGS, "\n"
		"SBFrameList()\n"
		"new_SBFrameList(SBFrameList rhs) -> SBFrameList\n"
		""},
	 { "delete_SBFrameList", _wrap_delete_SBFrameList, METH_O, "delete_SBFrameList(SBFrameList self)"},
	 { "SBFrameList___nonzero__", _wrap_SBFrameList___nonzero__, METH_O, "SBFrameList___nonzero__(SBFrameList self) -> bool"},
	 { "SBFrameList_IsValid", _wrap_SBFrameList_IsValid, METH_O, "SBFrameList_IsValid(SBFrameList self) -> bool"},
	 { "SBFrameList_GetSize", _wrap_SBFrameList_GetSize, METH_O, "Returns the number of frames in the list."},
	 { "SBFrameList_GetFrameAtIndex", _wrap_SBFrameList_GetFrameAtIndex, METH_VARARGS, "\n"
		"Returns the frame at the given index.\n"
		"\n"
		":type idx: int, in\n"
		":param idx:\n"
		"        The index of the frame to retrieve (0-based).\n"
		"\n"
		":rtype: :py:class:`SBFrame`\n"
		":return: \n"
		"        An SBFrame object for the frame at the specified index.\n"
		"        Returns an invalid SBFrame if idx is out of range.\n"
		""},
	 { "SBFrameList_GetThread", _wrap_SBFrameList_GetThread, METH_O, "\n"
		"Get the thread associated with this frame list.\n"
		"\n"
		":rtype: :py:class:`SBThread`\n"
		":return: \n"
		"        An SBThread object representing the thread.\n"
		""},
	 { "SBFrameList_Clear", _wrap_SBFrameList_Clear, METH_O, "Clear all frames from this list."},
	 { "SBFrameList_GetDescription", _wrap_SBFrameList_GetDescription, METH_VARARGS, "\n"
		"Get a description of this frame list.\n"
		"\n"
		":type description: :py:class:`SBStream`, in\n"
		":param description:\n"
		"        The stream to write the description to.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"        True if the description was successfully written.\n"
		""},
	 { "SBFrameList___str__", _wrap_SBFrameList___str__, METH_O, "SBFrameList___str__(SBFrameList self) -> std::string"},
	 { "SBFrameList_swigregister", SBFrameList_swigregister, METH_O, NULL},
	 { "SBFrameList_swiginit", SBFrameList_swiginit, METH_VARARGS, NULL},
	 { "new_SBFunction", _wrap_new_SBFunction, METH_VARARGS, "\n"
		"SBFunction()\n"
		"new_SBFunction(SBFunction rhs) -> SBFunction\n"
		""},
	 { "delete_SBFunction", _wrap_delete_SBFunction, METH_O, "delete_SBFunction(SBFunction self)"},
	 { "SBFunction___nonzero__", _wrap_SBFunction___nonzero__, METH_O, "SBFunction___nonzero__(SBFunction self) -> bool"},
	 { "SBFunction_IsValid", _wrap_SBFunction_IsValid, METH_O, "SBFunction_IsValid(SBFunction self) -> bool"},
	 { "SBFunction_GetName", _wrap_SBFunction_GetName, METH_O, "SBFunction_GetName(SBFunction self) -> char const *"},
	 { "SBFunction_GetDisplayName", _wrap_SBFunction_GetDisplayName, METH_O, "SBFunction_GetDisplayName(SBFunction self) -> char const *"},
	 { "SBFunction_GetMangledName", _wrap_SBFunction_GetMangledName, METH_O, "SBFunction_GetMangledName(SBFunction self) -> char const *"},
	 { "SBFunction_GetBaseName", _wrap_SBFunction_GetBaseName, METH_O, "SBFunction_GetBaseName(SBFunction self) -> char const *"},
	 { "SBFunction_GetInstructions", _wrap_SBFunction_GetInstructions, METH_VARARGS, "\n"
		"SBFunction_GetInstructions(SBFunction self, SBTarget target) -> SBInstructionList\n"
		"SBFunction_GetInstructions(SBFunction self, SBTarget target, char const * flavor) -> SBInstructionList\n"
		""},
	 { "SBFunction_GetStartAddress", _wrap_SBFunction_GetStartAddress, METH_O, "SBFunction_GetStartAddress(SBFunction self) -> SBAddress"},
	 { "SBFunction_GetEndAddress", _wrap_SBFunction_GetEndAddress, METH_O, "SBFunction_GetEndAddress(SBFunction self) -> SBAddress"},
	 { "SBFunction_GetRanges", _wrap_SBFunction_GetRanges, METH_O, "SBFunction_GetRanges(SBFunction self) -> SBAddressRangeList"},
	 { "SBFunction_GetArgumentName", _wrap_SBFunction_GetArgumentName, METH_VARARGS, "SBFunction_GetArgumentName(SBFunction self, uint32_t arg_idx) -> char const *"},
	 { "SBFunction_GetPrologueByteSize", _wrap_SBFunction_GetPrologueByteSize, METH_O, "SBFunction_GetPrologueByteSize(SBFunction self) -> uint32_t"},
	 { "SBFunction_GetType", _wrap_SBFunction_GetType, METH_O, "SBFunction_GetType(SBFunction self) -> SBType"},
	 { "SBFunction_GetBlock", _wrap_SBFunction_GetBlock, METH_O, "SBFunction_GetBlock(SBFunction self) -> SBBlock"},
	 { "SBFunction_GetLanguage", _wrap_SBFunction_GetLanguage, METH_O, "SBFunction_GetLanguage(SBFunction self) -> lldb::LanguageType"},
	 { "SBFunction_GetIsOptimized", _wrap_SBFunction_GetIsOptimized, METH_O, "\n"
		"SBFunction_GetIsOptimized(SBFunction self) -> bool\n"
		"\n"
		"    Returns true if the function was compiled with optimization.\n"
		"    Optimization, in this case, is meant to indicate that the debugger\n"
		"    experience may be confusing for the user -- variables optimized away,\n"
		"    stepping jumping between source lines -- and the driver may want to\n"
		"    provide some guidance to the user about this.\n"
		"    Returns false if unoptimized, or unknown.\n"
		""},
	 { "SBFunction___eq__", _wrap_SBFunction___eq__, METH_VARARGS, "SBFunction___eq__(SBFunction self, SBFunction rhs) -> bool"},
	 { "SBFunction___ne__", _wrap_SBFunction___ne__, METH_VARARGS, "SBFunction___ne__(SBFunction self, SBFunction rhs) -> bool"},
	 { "SBFunction_GetDescription", _wrap_SBFunction_GetDescription, METH_VARARGS, "SBFunction_GetDescription(SBFunction self, SBStream description) -> bool"},
	 { "SBFunction___repr__", _wrap_SBFunction___repr__, METH_O, "SBFunction___repr__(SBFunction self) -> std::string"},
	 { "SBFunction_swigregister", SBFunction_swigregister, METH_O, NULL},
	 { "SBFunction_swiginit", SBFunction_swiginit, METH_VARARGS, NULL},
	 { "SBHostOS_GetProgramFileSpec", _wrap_SBHostOS_GetProgramFileSpec, METH_NOARGS, "SBHostOS_GetProgramFileSpec() -> SBFileSpec"},
	 { "SBHostOS_GetLLDBPythonPath", _wrap_SBHostOS_GetLLDBPythonPath, METH_NOARGS, "SBHostOS_GetLLDBPythonPath() -> SBFileSpec"},
	 { "SBHostOS_GetLLDBPath", _wrap_SBHostOS_GetLLDBPath, METH_O, "SBHostOS_GetLLDBPath(lldb::PathType path_type) -> SBFileSpec"},
	 { "SBHostOS_GetUserHomeDirectory", _wrap_SBHostOS_GetUserHomeDirectory, METH_NOARGS, "SBHostOS_GetUserHomeDirectory() -> SBFileSpec"},
	 { "SBHostOS_ThreadCreated", _wrap_SBHostOS_ThreadCreated, METH_O, "SBHostOS_ThreadCreated(char const * name)"},
	 { "SBHostOS_ThreadCreate", _wrap_SBHostOS_ThreadCreate, METH_VARARGS, "SBHostOS_ThreadCreate(char const * name, lldb::thread_func_t thread_function, void * thread_arg, SBError err) -> lldb::thread_t"},
	 { "SBHostOS_ThreadCancel", _wrap_SBHostOS_ThreadCancel, METH_VARARGS, "SBHostOS_ThreadCancel(lldb::thread_t thread, SBError err) -> bool"},
	 { "SBHostOS_ThreadDetach", _wrap_SBHostOS_ThreadDetach, METH_VARARGS, "SBHostOS_ThreadDetach(lldb::thread_t thread, SBError err) -> bool"},
	 { "SBHostOS_ThreadJoin", _wrap_SBHostOS_ThreadJoin, METH_VARARGS, "SBHostOS_ThreadJoin(lldb::thread_t thread, lldb::thread_result_t * result, SBError err) -> bool"},
	 { "new_SBHostOS", _wrap_new_SBHostOS, METH_NOARGS, "new_SBHostOS() -> SBHostOS"},
	 { "delete_SBHostOS", _wrap_delete_SBHostOS, METH_O, "delete_SBHostOS(SBHostOS self)"},
	 { "SBHostOS_swigregister", SBHostOS_swigregister, METH_O, NULL},
	 { "SBHostOS_swiginit", SBHostOS_swiginit, METH_VARARGS, NULL},
	 { "new_SBInstruction", _wrap_new_SBInstruction, METH_VARARGS, "\n"
		"SBInstruction()\n"
		"new_SBInstruction(SBInstruction rhs) -> SBInstruction\n"
		""},
	 { "delete_SBInstruction", _wrap_delete_SBInstruction, METH_O, "delete_SBInstruction(SBInstruction self)"},
	 { "SBInstruction___nonzero__", _wrap_SBInstruction___nonzero__, METH_O, "SBInstruction___nonzero__(SBInstruction self) -> bool"},
	 { "SBInstruction_IsValid", _wrap_SBInstruction_IsValid, METH_O, "SBInstruction_IsValid(SBInstruction self) -> bool"},
	 { "SBInstruction_GetAddress", _wrap_SBInstruction_GetAddress, METH_O, "SBInstruction_GetAddress(SBInstruction self) -> SBAddress"},
	 { "SBInstruction_GetMnemonic", _wrap_SBInstruction_GetMnemonic, METH_VARARGS, "SBInstruction_GetMnemonic(SBInstruction self, SBTarget target) -> char const *"},
	 { "SBInstruction_GetOperands", _wrap_SBInstruction_GetOperands, METH_VARARGS, "SBInstruction_GetOperands(SBInstruction self, SBTarget target) -> char const *"},
	 { "SBInstruction_GetComment", _wrap_SBInstruction_GetComment, METH_VARARGS, "SBInstruction_GetComment(SBInstruction self, SBTarget target) -> char const *"},
	 { "SBInstruction_GetControlFlowKind", _wrap_SBInstruction_GetControlFlowKind, METH_VARARGS, "SBInstruction_GetControlFlowKind(SBInstruction self, SBTarget target) -> lldb::InstructionControlFlowKind"},
	 { "SBInstruction_GetData", _wrap_SBInstruction_GetData, METH_VARARGS, "SBInstruction_GetData(SBInstruction self, SBTarget target) -> SBData"},
	 { "SBInstruction_GetByteSize", _wrap_SBInstruction_GetByteSize, METH_O, "SBInstruction_GetByteSize(SBInstruction self) -> size_t"},
	 { "SBInstruction_DoesBranch", _wrap_SBInstruction_DoesBranch, METH_O, "SBInstruction_DoesBranch(SBInstruction self) -> bool"},
	 { "SBInstruction_HasDelaySlot", _wrap_SBInstruction_HasDelaySlot, METH_O, "SBInstruction_HasDelaySlot(SBInstruction self) -> bool"},
	 { "SBInstruction_CanSetBreakpoint", _wrap_SBInstruction_CanSetBreakpoint, METH_O, "SBInstruction_CanSetBreakpoint(SBInstruction self) -> bool"},
	 { "SBInstruction_Print", _wrap_SBInstruction_Print, METH_VARARGS, "\n"
		"SBInstruction_Print(SBInstruction self, SBFile out)\n"
		"SBInstruction_Print(SBInstruction self, lldb::FileSP BORROWED)\n"
		""},
	 { "SBInstruction_GetDescription", _wrap_SBInstruction_GetDescription, METH_VARARGS, "SBInstruction_GetDescription(SBInstruction self, SBStream description) -> bool"},
	 { "SBInstruction_EmulateWithFrame", _wrap_SBInstruction_EmulateWithFrame, METH_VARARGS, "SBInstruction_EmulateWithFrame(SBInstruction self, SBFrame frame, uint32_t evaluate_options) -> bool"},
	 { "SBInstruction_DumpEmulation", _wrap_SBInstruction_DumpEmulation, METH_VARARGS, "SBInstruction_DumpEmulation(SBInstruction self, char const * triple) -> bool"},
	 { "SBInstruction_TestEmulation", _wrap_SBInstruction_TestEmulation, METH_VARARGS, "SBInstruction_TestEmulation(SBInstruction self, SBStream output_stream, char const * test_file) -> bool"},
	 { "SBInstruction___repr__", _wrap_SBInstruction___repr__, METH_O, "SBInstruction___repr__(SBInstruction self) -> std::string"},
	 { "SBInstruction_swigregister", SBInstruction_swigregister, METH_O, NULL},
	 { "SBInstruction_swiginit", SBInstruction_swiginit, METH_VARARGS, NULL},
	 { "new_SBInstructionList", _wrap_new_SBInstructionList, METH_VARARGS, "\n"
		"SBInstructionList()\n"
		"new_SBInstructionList(SBInstructionList rhs) -> SBInstructionList\n"
		""},
	 { "delete_SBInstructionList", _wrap_delete_SBInstructionList, METH_O, "delete_SBInstructionList(SBInstructionList self)"},
	 { "SBInstructionList___nonzero__", _wrap_SBInstructionList___nonzero__, METH_O, "SBInstructionList___nonzero__(SBInstructionList self) -> bool"},
	 { "SBInstructionList_IsValid", _wrap_SBInstructionList_IsValid, METH_O, "SBInstructionList_IsValid(SBInstructionList self) -> bool"},
	 { "SBInstructionList_GetSize", _wrap_SBInstructionList_GetSize, METH_O, "SBInstructionList_GetSize(SBInstructionList self) -> size_t"},
	 { "SBInstructionList_GetInstructionAtIndex", _wrap_SBInstructionList_GetInstructionAtIndex, METH_VARARGS, "SBInstructionList_GetInstructionAtIndex(SBInstructionList self, uint32_t idx) -> SBInstruction"},
	 { "SBInstructionList_GetInstructionsCount", _wrap_SBInstructionList_GetInstructionsCount, METH_VARARGS, "SBInstructionList_GetInstructionsCount(SBInstructionList self, SBAddress start, SBAddress end, bool canSetBreakpoint=False) -> size_t"},
	 { "SBInstructionList_Clear", _wrap_SBInstructionList_Clear, METH_O, "SBInstructionList_Clear(SBInstructionList self)"},
	 { "SBInstructionList_AppendInstruction", _wrap_SBInstructionList_AppendInstruction, METH_VARARGS, "SBInstructionList_AppendInstruction(SBInstructionList self, SBInstruction inst)"},
	 { "SBInstructionList_Print", _wrap_SBInstructionList_Print, METH_VARARGS, "\n"
		"SBInstructionList_Print(SBInstructionList self, SBFile out)\n"
		"SBInstructionList_Print(SBInstructionList self, lldb::FileSP BORROWED)\n"
		""},
	 { "SBInstructionList_GetDescription", _wrap_SBInstructionList_GetDescription, METH_VARARGS, "\n"
		"SBInstructionList_GetDescription(SBInstructionList self, SBStream description) -> bool\n"
		"SBInstructionList_GetDescription(SBInstructionList self, SBStream description, SBExecutionContext exe_ctx) -> bool\n"
		""},
	 { "SBInstructionList_DumpEmulationForAllInstructions", _wrap_SBInstructionList_DumpEmulationForAllInstructions, METH_VARARGS, "SBInstructionList_DumpEmulationForAllInstructions(SBInstructionList self, char const * triple) -> bool"},
	 { "SBInstructionList___repr__", _wrap_SBInstructionList___repr__, METH_O, "SBInstructionList___repr__(SBInstructionList self) -> std::string"},
	 { "SBInstructionList_swigregister", SBInstructionList_swigregister, METH_O, NULL},
	 { "SBInstructionList_swiginit", SBInstructionList_swiginit, METH_VARARGS, NULL},
	 { "SBLanguageRuntime_GetLanguageTypeFromString", _wrap_SBLanguageRuntime_GetLanguageTypeFromString, METH_O, "SBLanguageRuntime_GetLanguageTypeFromString(char const * string) -> lldb::LanguageType"},
	 { "SBLanguageRuntime_GetNameForLanguageType", _wrap_SBLanguageRuntime_GetNameForLanguageType, METH_O, "SBLanguageRuntime_GetNameForLanguageType(lldb::LanguageType language) -> char const *"},
	 { "SBLanguageRuntime_LanguageIsCPlusPlus", _wrap_SBLanguageRuntime_LanguageIsCPlusPlus, METH_O, "Returns whether the given language is any version of C++."},
	 { "SBLanguageRuntime_LanguageIsObjC", _wrap_SBLanguageRuntime_LanguageIsObjC, METH_O, "Returns whether the given language is Obj-C or Obj-C++."},
	 { "SBLanguageRuntime_LanguageIsCFamily", _wrap_SBLanguageRuntime_LanguageIsCFamily, METH_O, "Returns whether the given language is any version of C, C++ or Obj-C."},
	 { "SBLanguageRuntime_SupportsExceptionBreakpointsOnThrow", _wrap_SBLanguageRuntime_SupportsExceptionBreakpointsOnThrow, METH_O, "\n"
		"Returns whether the given language supports exception breakpoints on\n"
		"throw statements.\n"
		""},
	 { "SBLanguageRuntime_SupportsExceptionBreakpointsOnCatch", _wrap_SBLanguageRuntime_SupportsExceptionBreakpointsOnCatch, METH_O, "\n"
		"Returns whether the given language supports exception breakpoints on\n"
		"catch statements.\n"
		""},
	 { "SBLanguageRuntime_GetThrowKeywordForLanguage", _wrap_SBLanguageRuntime_GetThrowKeywordForLanguage, METH_O, "\n"
		"Returns the keyword used for throw statements in the given language, e.g.\n"
		"Python uses **raise**. Returns **nullptr** if the language is not supported.\n"
		""},
	 { "SBLanguageRuntime_GetCatchKeywordForLanguage", _wrap_SBLanguageRuntime_GetCatchKeywordForLanguage, METH_O, "\n"
		"Returns the keyword used for catch statements in the given language, e.g.\n"
		"Python uses **except**. Returns **nullptr** if the language is not\n"
		"supported.\n"
		""},
	 { "new_SBLanguageRuntime", _wrap_new_SBLanguageRuntime, METH_NOARGS, "new_SBLanguageRuntime() -> SBLanguageRuntime"},
	 { "delete_SBLanguageRuntime", _wrap_delete_SBLanguageRuntime, METH_O, "delete_SBLanguageRuntime(SBLanguageRuntime self)"},
	 { "SBLanguageRuntime_swigregister", SBLanguageRuntime_swigregister, METH_O, NULL},
	 { "SBLanguageRuntime_swiginit", SBLanguageRuntime_swiginit, METH_VARARGS, NULL},
	 { "new_SBLaunchInfo", _wrap_new_SBLaunchInfo, METH_O, "new_SBLaunchInfo(char const ** argv) -> SBLaunchInfo"},
	 { "delete_SBLaunchInfo", _wrap_delete_SBLaunchInfo, METH_O, "delete_SBLaunchInfo(SBLaunchInfo self)"},
	 { "SBLaunchInfo_GetProcessID", _wrap_SBLaunchInfo_GetProcessID, METH_O, "SBLaunchInfo_GetProcessID(SBLaunchInfo self) -> lldb::pid_t"},
	 { "SBLaunchInfo_GetUserID", _wrap_SBLaunchInfo_GetUserID, METH_O, "SBLaunchInfo_GetUserID(SBLaunchInfo self) -> uint32_t"},
	 { "SBLaunchInfo_GetGroupID", _wrap_SBLaunchInfo_GetGroupID, METH_O, "SBLaunchInfo_GetGroupID(SBLaunchInfo self) -> uint32_t"},
	 { "SBLaunchInfo_UserIDIsValid", _wrap_SBLaunchInfo_UserIDIsValid, METH_O, "SBLaunchInfo_UserIDIsValid(SBLaunchInfo self) -> bool"},
	 { "SBLaunchInfo_GroupIDIsValid", _wrap_SBLaunchInfo_GroupIDIsValid, METH_O, "SBLaunchInfo_GroupIDIsValid(SBLaunchInfo self) -> bool"},
	 { "SBLaunchInfo_SetUserID", _wrap_SBLaunchInfo_SetUserID, METH_VARARGS, "SBLaunchInfo_SetUserID(SBLaunchInfo self, uint32_t uid)"},
	 { "SBLaunchInfo_SetGroupID", _wrap_SBLaunchInfo_SetGroupID, METH_VARARGS, "SBLaunchInfo_SetGroupID(SBLaunchInfo self, uint32_t gid)"},
	 { "SBLaunchInfo_GetExecutableFile", _wrap_SBLaunchInfo_GetExecutableFile, METH_O, "SBLaunchInfo_GetExecutableFile(SBLaunchInfo self) -> SBFileSpec"},
	 { "SBLaunchInfo_SetExecutableFile", _wrap_SBLaunchInfo_SetExecutableFile, METH_VARARGS, "\n"
		"Set the executable file that will be used to launch the process and\n"
		"optionally set it as the first argument in the argument vector.\n"
		"\n"
		"This only needs to be specified if clients wish to carefully control\n"
		"the exact path will be used to launch a binary. If you create a\n"
		"target with a symlink, that symlink will get resolved in the target\n"
		"and the resolved path will get used to launch the process. Calling\n"
		"this function can help you still launch your process using the\n"
		"path of your choice.\n"
		"\n"
		"If this function is not called prior to launching with\n"
		"SBTarget::Launch(...), the target will use the resolved executable\n"
		"path that was used to create the target.\n"
		"\n"
		":type exe_file: :py:class:`SBFileSpec`, in\n"
		":param exe_file:\n"
		"        The override path to use when launching the executable.\n"
		"\n"
		":type add_as_first_arg: boolean, in\n"
		":param add_as_first_arg:\n"
		"        If true, then the path will be inserted into the argument vector\n"
		"        prior to launching. Otherwise the argument vector will be left\n"
		"        alone.\n"
		""},
	 { "SBLaunchInfo_GetListener", _wrap_SBLaunchInfo_GetListener, METH_O, "\n"
		"Get the listener that will be used to receive process events.\n"
		"\n"
		"If no listener has been set via a call to\n"
		"SBLaunchInfo::SetListener(), then an invalid SBListener will be\n"
		"returned (SBListener::IsValid() will return false). If a listener\n"
		"has been set, then the valid listener object will be returned.\n"
		""},
	 { "SBLaunchInfo_SetListener", _wrap_SBLaunchInfo_SetListener, METH_VARARGS, "\n"
		"Set the listener that will be used to receive process events.\n"
		"\n"
		"By default the SBDebugger, which has a listener, that the SBTarget\n"
		"belongs to will listen for the process events. Calling this function\n"
		"allows a different listener to be used to listen for process events.\n"
		""},
	 { "SBLaunchInfo_GetShadowListener", _wrap_SBLaunchInfo_GetShadowListener, METH_O, "\n"
		"Get the shadow listener that receive public process events,\n"
		"additionally to the default process event listener.\n"
		"\n"
		"If no listener has been set via a call to\n"
		"SBLaunchInfo::SetShadowListener(), then an invalid SBListener will\n"
		"be returned (SBListener::IsValid() will return false). If a listener\n"
		"has been set, then the valid listener object will be returned.\n"
		""},
	 { "SBLaunchInfo_SetShadowListener", _wrap_SBLaunchInfo_SetShadowListener, METH_VARARGS, "\n"
		"Set the shadow listener that will receive public process events,\n"
		"additionally to the default process event listener.\n"
		"\n"
		"By default a process have no shadow event listener.\n"
		"Calling this function allows public process events to be broadcasted to an\n"
		"additional listener on top of the default process event listener.\n"
		"If the `listener` argument is invalid (SBListener::IsValid() will\n"
		"return false), this will clear the shadow listener.\n"
		""},
	 { "SBLaunchInfo_GetNumArguments", _wrap_SBLaunchInfo_GetNumArguments, METH_O, "SBLaunchInfo_GetNumArguments(SBLaunchInfo self) -> uint32_t"},
	 { "SBLaunchInfo_GetArgumentAtIndex", _wrap_SBLaunchInfo_GetArgumentAtIndex, METH_VARARGS, "SBLaunchInfo_GetArgumentAtIndex(SBLaunchInfo self, uint32_t idx) -> char const *"},
	 { "SBLaunchInfo_SetArguments", _wrap_SBLaunchInfo_SetArguments, METH_VARARGS, "SBLaunchInfo_SetArguments(SBLaunchInfo self, char const ** argv, bool append)"},
	 { "SBLaunchInfo_GetNumEnvironmentEntries", _wrap_SBLaunchInfo_GetNumEnvironmentEntries, METH_O, "SBLaunchInfo_GetNumEnvironmentEntries(SBLaunchInfo self) -> uint32_t"},
	 { "SBLaunchInfo_GetEnvironmentEntryAtIndex", _wrap_SBLaunchInfo_GetEnvironmentEntryAtIndex, METH_VARARGS, "SBLaunchInfo_GetEnvironmentEntryAtIndex(SBLaunchInfo self, uint32_t idx) -> char const *"},
	 { "SBLaunchInfo_SetEnvironmentEntries", _wrap_SBLaunchInfo_SetEnvironmentEntries, METH_VARARGS, "\n"
		"Update this object with the given environment variables.\n"
		"\n"
		"If append is false, the provided environment will replace the existing\n"
		"environment. Otherwise, existing values will be updated of left untouched\n"
		"accordingly.\n"
		"\n"
		":param [in]: envp\n"
		"        The new environment variables as a list of strings with the following\n"
		"        format\n"
		"            name=value\n"
		"\n"
		":param [in]: append\n"
		"        Flag that controls whether to replace the existing environment.\n"
		""},
	 { "SBLaunchInfo_SetEnvironment", _wrap_SBLaunchInfo_SetEnvironment, METH_VARARGS, "\n"
		"Update this object with the given environment variables.\n"
		"\n"
		"If append is false, the provided environment will replace the existing\n"
		"environment. Otherwise, existing values will be updated of left untouched\n"
		"accordingly.\n"
		"\n"
		":param [in]: env\n"
		"        The new environment variables.\n"
		"\n"
		":param [in]: append\n"
		"        Flag that controls whether to replace the existing environment.\n"
		""},
	 { "SBLaunchInfo_GetEnvironment", _wrap_SBLaunchInfo_GetEnvironment, METH_O, "\n"
		"Return the environment variables of this object.\n"
		"\n"
		":rtype: :py:class:`SBEnvironment`\n"
		":return: \n"
		"        An lldb::SBEnvironment object which is a copy of the SBLaunchInfo's\n"
		"        environment.\n"
		""},
	 { "SBLaunchInfo_Clear", _wrap_SBLaunchInfo_Clear, METH_O, "SBLaunchInfo_Clear(SBLaunchInfo self)"},
	 { "SBLaunchInfo_GetWorkingDirectory", _wrap_SBLaunchInfo_GetWorkingDirectory, METH_O, "SBLaunchInfo_GetWorkingDirectory(SBLaunchInfo self) -> char const *"},
	 { "SBLaunchInfo_SetWorkingDirectory", _wrap_SBLaunchInfo_SetWorkingDirectory, METH_VARARGS, "SBLaunchInfo_SetWorkingDirectory(SBLaunchInfo self, char const * working_dir)"},
	 { "SBLaunchInfo_GetLaunchFlags", _wrap_SBLaunchInfo_GetLaunchFlags, METH_O, "SBLaunchInfo_GetLaunchFlags(SBLaunchInfo self) -> uint32_t"},
	 { "SBLaunchInfo_SetLaunchFlags", _wrap_SBLaunchInfo_SetLaunchFlags, METH_VARARGS, "SBLaunchInfo_SetLaunchFlags(SBLaunchInfo self, uint32_t flags)"},
	 { "SBLaunchInfo_GetProcessPluginName", _wrap_SBLaunchInfo_GetProcessPluginName, METH_O, "SBLaunchInfo_GetProcessPluginName(SBLaunchInfo self) -> char const *"},
	 { "SBLaunchInfo_SetProcessPluginName", _wrap_SBLaunchInfo_SetProcessPluginName, METH_VARARGS, "SBLaunchInfo_SetProcessPluginName(SBLaunchInfo self, char const * plugin_name)"},
	 { "SBLaunchInfo_GetShell", _wrap_SBLaunchInfo_GetShell, METH_O, "SBLaunchInfo_GetShell(SBLaunchInfo self) -> char const *"},
	 { "SBLaunchInfo_SetShell", _wrap_SBLaunchInfo_SetShell, METH_VARARGS, "SBLaunchInfo_SetShell(SBLaunchInfo self, char const * path)"},
	 { "SBLaunchInfo_GetShellExpandArguments", _wrap_SBLaunchInfo_GetShellExpandArguments, METH_O, "SBLaunchInfo_GetShellExpandArguments(SBLaunchInfo self) -> bool"},
	 { "SBLaunchInfo_SetShellExpandArguments", _wrap_SBLaunchInfo_SetShellExpandArguments, METH_VARARGS, "SBLaunchInfo_SetShellExpandArguments(SBLaunchInfo self, bool expand)"},
	 { "SBLaunchInfo_GetResumeCount", _wrap_SBLaunchInfo_GetResumeCount, METH_O, "SBLaunchInfo_GetResumeCount(SBLaunchInfo self) -> uint32_t"},
	 { "SBLaunchInfo_SetResumeCount", _wrap_SBLaunchInfo_SetResumeCount, METH_VARARGS, "SBLaunchInfo_SetResumeCount(SBLaunchInfo self, uint32_t c)"},
	 { "SBLaunchInfo_AddCloseFileAction", _wrap_SBLaunchInfo_AddCloseFileAction, METH_VARARGS, "SBLaunchInfo_AddCloseFileAction(SBLaunchInfo self, int fd) -> bool"},
	 { "SBLaunchInfo_AddDuplicateFileAction", _wrap_SBLaunchInfo_AddDuplicateFileAction, METH_VARARGS, "SBLaunchInfo_AddDuplicateFileAction(SBLaunchInfo self, int fd, int dup_fd) -> bool"},
	 { "SBLaunchInfo_AddOpenFileAction", _wrap_SBLaunchInfo_AddOpenFileAction, METH_VARARGS, "SBLaunchInfo_AddOpenFileAction(SBLaunchInfo self, int fd, char const * path, bool read, bool write) -> bool"},
	 { "SBLaunchInfo_AddSuppressFileAction", _wrap_SBLaunchInfo_AddSuppressFileAction, METH_VARARGS, "SBLaunchInfo_AddSuppressFileAction(SBLaunchInfo self, int fd, bool read, bool write) -> bool"},
	 { "SBLaunchInfo_SetLaunchEventData", _wrap_SBLaunchInfo_SetLaunchEventData, METH_VARARGS, "SBLaunchInfo_SetLaunchEventData(SBLaunchInfo self, char const * data)"},
	 { "SBLaunchInfo_GetLaunchEventData", _wrap_SBLaunchInfo_GetLaunchEventData, METH_O, "SBLaunchInfo_GetLaunchEventData(SBLaunchInfo self) -> char const *"},
	 { "SBLaunchInfo_GetDetachOnError", _wrap_SBLaunchInfo_GetDetachOnError, METH_O, "SBLaunchInfo_GetDetachOnError(SBLaunchInfo self) -> bool"},
	 { "SBLaunchInfo_SetDetachOnError", _wrap_SBLaunchInfo_SetDetachOnError, METH_VARARGS, "SBLaunchInfo_SetDetachOnError(SBLaunchInfo self, bool enable)"},
	 { "SBLaunchInfo_GetScriptedProcessClassName", _wrap_SBLaunchInfo_GetScriptedProcessClassName, METH_O, "SBLaunchInfo_GetScriptedProcessClassName(SBLaunchInfo self) -> char const *"},
	 { "SBLaunchInfo_SetScriptedProcessClassName", _wrap_SBLaunchInfo_SetScriptedProcessClassName, METH_VARARGS, "SBLaunchInfo_SetScriptedProcessClassName(SBLaunchInfo self, char const * class_name)"},
	 { "SBLaunchInfo_GetScriptedProcessDictionary", _wrap_SBLaunchInfo_GetScriptedProcessDictionary, METH_O, "SBLaunchInfo_GetScriptedProcessDictionary(SBLaunchInfo self) -> SBStructuredData"},
	 { "SBLaunchInfo_SetScriptedProcessDictionary", _wrap_SBLaunchInfo_SetScriptedProcessDictionary, METH_VARARGS, "SBLaunchInfo_SetScriptedProcessDictionary(SBLaunchInfo self, SBStructuredData dict)"},
	 { "SBLaunchInfo_swigregister", SBLaunchInfo_swigregister, METH_O, NULL},
	 { "SBLaunchInfo_swiginit", SBLaunchInfo_swiginit, METH_VARARGS, NULL},
	 { "new_SBLineEntry", _wrap_new_SBLineEntry, METH_VARARGS, "\n"
		"SBLineEntry()\n"
		"new_SBLineEntry(SBLineEntry rhs) -> SBLineEntry\n"
		""},
	 { "delete_SBLineEntry", _wrap_delete_SBLineEntry, METH_O, "delete_SBLineEntry(SBLineEntry self)"},
	 { "SBLineEntry_GetStartAddress", _wrap_SBLineEntry_GetStartAddress, METH_O, "SBLineEntry_GetStartAddress(SBLineEntry self) -> SBAddress"},
	 { "SBLineEntry_GetEndAddress", _wrap_SBLineEntry_GetEndAddress, METH_O, "SBLineEntry_GetEndAddress(SBLineEntry self) -> SBAddress"},
	 { "SBLineEntry_GetSameLineContiguousAddressRangeEnd", _wrap_SBLineEntry_GetSameLineContiguousAddressRangeEnd, METH_VARARGS, "SBLineEntry_GetSameLineContiguousAddressRangeEnd(SBLineEntry self, bool include_inlined_functions) -> SBAddress"},
	 { "SBLineEntry___nonzero__", _wrap_SBLineEntry___nonzero__, METH_O, "SBLineEntry___nonzero__(SBLineEntry self) -> bool"},
	 { "SBLineEntry_IsValid", _wrap_SBLineEntry_IsValid, METH_O, "SBLineEntry_IsValid(SBLineEntry self) -> bool"},
	 { "SBLineEntry_GetFileSpec", _wrap_SBLineEntry_GetFileSpec, METH_O, "SBLineEntry_GetFileSpec(SBLineEntry self) -> SBFileSpec"},
	 { "SBLineEntry_GetLine", _wrap_SBLineEntry_GetLine, METH_O, "SBLineEntry_GetLine(SBLineEntry self) -> uint32_t"},
	 { "SBLineEntry_GetColumn", _wrap_SBLineEntry_GetColumn, METH_O, "SBLineEntry_GetColumn(SBLineEntry self) -> uint32_t"},
	 { "SBLineEntry_SetFileSpec", _wrap_SBLineEntry_SetFileSpec, METH_VARARGS, "SBLineEntry_SetFileSpec(SBLineEntry self, SBFileSpec filespec)"},
	 { "SBLineEntry_SetLine", _wrap_SBLineEntry_SetLine, METH_VARARGS, "SBLineEntry_SetLine(SBLineEntry self, uint32_t line)"},
	 { "SBLineEntry_SetColumn", _wrap_SBLineEntry_SetColumn, METH_VARARGS, "SBLineEntry_SetColumn(SBLineEntry self, uint32_t column)"},
	 { "SBLineEntry___eq__", _wrap_SBLineEntry___eq__, METH_VARARGS, "SBLineEntry___eq__(SBLineEntry self, SBLineEntry rhs) -> bool"},
	 { "SBLineEntry___ne__", _wrap_SBLineEntry___ne__, METH_VARARGS, "SBLineEntry___ne__(SBLineEntry self, SBLineEntry rhs) -> bool"},
	 { "SBLineEntry_GetDescription", _wrap_SBLineEntry_GetDescription, METH_VARARGS, "SBLineEntry_GetDescription(SBLineEntry self, SBStream description) -> bool"},
	 { "SBLineEntry___repr__", _wrap_SBLineEntry___repr__, METH_O, "SBLineEntry___repr__(SBLineEntry self) -> std::string"},
	 { "SBLineEntry_swigregister", SBLineEntry_swigregister, METH_O, NULL},
	 { "SBLineEntry_swiginit", SBLineEntry_swiginit, METH_VARARGS, NULL},
	 { "new_SBListener", _wrap_new_SBListener, METH_VARARGS, "\n"
		"SBListener()\n"
		"SBListener(char const * name)\n"
		"new_SBListener(SBListener rhs) -> SBListener\n"
		""},
	 { "delete_SBListener", _wrap_delete_SBListener, METH_O, "delete_SBListener(SBListener self)"},
	 { "SBListener_AddEvent", _wrap_SBListener_AddEvent, METH_VARARGS, "SBListener_AddEvent(SBListener self, SBEvent event)"},
	 { "SBListener_Clear", _wrap_SBListener_Clear, METH_O, "SBListener_Clear(SBListener self)"},
	 { "SBListener___nonzero__", _wrap_SBListener___nonzero__, METH_O, "SBListener___nonzero__(SBListener self) -> bool"},
	 { "SBListener_IsValid", _wrap_SBListener_IsValid, METH_O, "SBListener_IsValid(SBListener self) -> bool"},
	 { "SBListener_StartListeningForEventClass", _wrap_SBListener_StartListeningForEventClass, METH_VARARGS, "SBListener_StartListeningForEventClass(SBListener self, SBDebugger debugger, char const * broadcaster_class, uint32_t event_mask) -> uint32_t"},
	 { "SBListener_StopListeningForEventClass", _wrap_SBListener_StopListeningForEventClass, METH_VARARGS, "SBListener_StopListeningForEventClass(SBListener self, SBDebugger debugger, char const * broadcaster_class, uint32_t event_mask) -> bool"},
	 { "SBListener_StartListeningForEvents", _wrap_SBListener_StartListeningForEvents, METH_VARARGS, "SBListener_StartListeningForEvents(SBListener self, SBBroadcaster broadcaster, uint32_t event_mask) -> uint32_t"},
	 { "SBListener_StopListeningForEvents", _wrap_SBListener_StopListeningForEvents, METH_VARARGS, "SBListener_StopListeningForEvents(SBListener self, SBBroadcaster broadcaster, uint32_t event_mask) -> bool"},
	 { "SBListener_WaitForEvent", _wrap_SBListener_WaitForEvent, METH_VARARGS, "SBListener_WaitForEvent(SBListener self, uint32_t num_seconds, SBEvent event) -> bool"},
	 { "SBListener_WaitForEventForBroadcaster", _wrap_SBListener_WaitForEventForBroadcaster, METH_VARARGS, "SBListener_WaitForEventForBroadcaster(SBListener self, uint32_t num_seconds, SBBroadcaster broadcaster, SBEvent sb_event) -> bool"},
	 { "SBListener_WaitForEventForBroadcasterWithType", _wrap_SBListener_WaitForEventForBroadcasterWithType, METH_VARARGS, "SBListener_WaitForEventForBroadcasterWithType(SBListener self, uint32_t num_seconds, SBBroadcaster broadcaster, uint32_t event_type_mask, SBEvent sb_event) -> bool"},
	 { "SBListener_PeekAtNextEvent", _wrap_SBListener_PeekAtNextEvent, METH_VARARGS, "SBListener_PeekAtNextEvent(SBListener self, SBEvent sb_event) -> bool"},
	 { "SBListener_PeekAtNextEventForBroadcaster", _wrap_SBListener_PeekAtNextEventForBroadcaster, METH_VARARGS, "SBListener_PeekAtNextEventForBroadcaster(SBListener self, SBBroadcaster broadcaster, SBEvent sb_event) -> bool"},
	 { "SBListener_PeekAtNextEventForBroadcasterWithType", _wrap_SBListener_PeekAtNextEventForBroadcasterWithType, METH_VARARGS, "SBListener_PeekAtNextEventForBroadcasterWithType(SBListener self, SBBroadcaster broadcaster, uint32_t event_type_mask, SBEvent sb_event) -> bool"},
	 { "SBListener_GetNextEvent", _wrap_SBListener_GetNextEvent, METH_VARARGS, "SBListener_GetNextEvent(SBListener self, SBEvent sb_event) -> bool"},
	 { "SBListener_GetNextEventForBroadcaster", _wrap_SBListener_GetNextEventForBroadcaster, METH_VARARGS, "SBListener_GetNextEventForBroadcaster(SBListener self, SBBroadcaster broadcaster, SBEvent sb_event) -> bool"},
	 { "SBListener_GetNextEventForBroadcasterWithType", _wrap_SBListener_GetNextEventForBroadcasterWithType, METH_VARARGS, "SBListener_GetNextEventForBroadcasterWithType(SBListener self, SBBroadcaster broadcaster, uint32_t event_type_mask, SBEvent sb_event) -> bool"},
	 { "SBListener_HandleBroadcastEvent", _wrap_SBListener_HandleBroadcastEvent, METH_VARARGS, "SBListener_HandleBroadcastEvent(SBListener self, SBEvent event) -> bool"},
	 { "SBListener_swigregister", SBListener_swigregister, METH_O, NULL},
	 { "SBListener_swiginit", SBListener_swiginit, METH_VARARGS, NULL},
	 { "new_SBMemoryRegionInfo", _wrap_new_SBMemoryRegionInfo, METH_VARARGS, "\n"
		"SBMemoryRegionInfo()\n"
		"SBMemoryRegionInfo(SBMemoryRegionInfo rhs)\n"
		"SBMemoryRegionInfo(char const * name, lldb::addr_t begin, lldb::addr_t end, uint32_t permissions, bool mapped, bool stack_memory=False)\n"
		""},
	 { "delete_SBMemoryRegionInfo", _wrap_delete_SBMemoryRegionInfo, METH_O, "delete_SBMemoryRegionInfo(SBMemoryRegionInfo self)"},
	 { "SBMemoryRegionInfo_Clear", _wrap_SBMemoryRegionInfo_Clear, METH_O, "SBMemoryRegionInfo_Clear(SBMemoryRegionInfo self)"},
	 { "SBMemoryRegionInfo_GetRegionBase", _wrap_SBMemoryRegionInfo_GetRegionBase, METH_O, "\n"
		"Get the base address of this memory range.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"        The base address of this memory range.\n"
		""},
	 { "SBMemoryRegionInfo_GetRegionEnd", _wrap_SBMemoryRegionInfo_GetRegionEnd, METH_O, "\n"
		"Get the end address of this memory range.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"        The base address of this memory range.\n"
		""},
	 { "SBMemoryRegionInfo_IsReadable", _wrap_SBMemoryRegionInfo_IsReadable, METH_O, "\n"
		"Check if this memory address is marked readable to the process.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"        true if this memory address is marked readable\n"
		""},
	 { "SBMemoryRegionInfo_IsWritable", _wrap_SBMemoryRegionInfo_IsWritable, METH_O, "\n"
		"Check if this memory address is marked writable to the process.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"        true if this memory address is marked writable\n"
		""},
	 { "SBMemoryRegionInfo_IsExecutable", _wrap_SBMemoryRegionInfo_IsExecutable, METH_O, "\n"
		"Check if this memory address is marked executable to the process.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"        true if this memory address is marked executable\n"
		""},
	 { "SBMemoryRegionInfo_IsMapped", _wrap_SBMemoryRegionInfo_IsMapped, METH_O, "\n"
		"Check if this memory address is mapped into the process address\n"
		"space.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"        true if this memory address is in the process address space.\n"
		""},
	 { "SBMemoryRegionInfo_GetName", _wrap_SBMemoryRegionInfo_GetName, METH_O, "\n"
		"Returns the name of the memory region mapped at the given\n"
		"address.\n"
		"\n"
		":rtype: string\n"
		":return: \n"
		"        In case of memory mapped files it is the absolute path of\n"
		"        the file otherwise it is a name associated with the memory\n"
		"        region. If no name can be determined the returns nullptr.\n"
		""},
	 { "SBMemoryRegionInfo_HasDirtyMemoryPageList", _wrap_SBMemoryRegionInfo_HasDirtyMemoryPageList, METH_O, "\n"
		"SBMemoryRegionInfo_HasDirtyMemoryPageList(SBMemoryRegionInfo self) -> bool\n"
		"\n"
		"        Returns whether this memory region has a list of modified (dirty)\n"
		"        pages available or not.  When calling GetNumDirtyPages(), you will\n"
		"        have 0 returned for both \"dirty page list is not known\" and \n"
		"        \"empty dirty page list\" (that is, no modified pages in this\n"
		"        memory region).  You must use this method to disambiguate.\n"
		""},
	 { "SBMemoryRegionInfo_GetNumDirtyPages", _wrap_SBMemoryRegionInfo_GetNumDirtyPages, METH_O, "\n"
		"SBMemoryRegionInfo_GetNumDirtyPages(SBMemoryRegionInfo self) -> uint32_t\n"
		"\n"
		"        Return the number of dirty (modified) memory pages in this\n"
		"        memory region, if available.  You must use the \n"
		"        SBMemoryRegionInfo::HasDirtyMemoryPageList() method to\n"
		"        determine if a dirty memory list is available; it will depend\n"
		"        on the target system can provide this information.\n"
		""},
	 { "SBMemoryRegionInfo_GetDirtyPageAddressAtIndex", _wrap_SBMemoryRegionInfo_GetDirtyPageAddressAtIndex, METH_VARARGS, "\n"
		"SBMemoryRegionInfo_GetDirtyPageAddressAtIndex(SBMemoryRegionInfo self, uint32_t idx) -> lldb::addr_t\n"
		"\n"
		"        Return the address of a modified, or dirty, page of memory.\n"
		"        If the provided index is out of range, or this memory region \n"
		"        does not have dirty page information, LLDB_INVALID_ADDRESS \n"
		"        is returned.\n"
		""},
	 { "SBMemoryRegionInfo_GetPageSize", _wrap_SBMemoryRegionInfo_GetPageSize, METH_O, "\n"
		"SBMemoryRegionInfo_GetPageSize(SBMemoryRegionInfo self) -> int\n"
		"\n"
		"        Return the size of pages in this memory region.  0 will be returned\n"
		"        if this information was unavailable.\n"
		""},
	 { "SBMemoryRegionInfo___eq__", _wrap_SBMemoryRegionInfo___eq__, METH_VARARGS, "SBMemoryRegionInfo___eq__(SBMemoryRegionInfo self, SBMemoryRegionInfo rhs) -> bool"},
	 { "SBMemoryRegionInfo___ne__", _wrap_SBMemoryRegionInfo___ne__, METH_VARARGS, "SBMemoryRegionInfo___ne__(SBMemoryRegionInfo self, SBMemoryRegionInfo rhs) -> bool"},
	 { "SBMemoryRegionInfo_GetDescription", _wrap_SBMemoryRegionInfo_GetDescription, METH_VARARGS, "\n"
		"SBMemoryRegionInfo_GetDescription(SBMemoryRegionInfo self, SBStream description) -> bool\n"
		"\n"
		"        Takes an SBStream parameter to write output to,\n"
		"        formatted [Hex start - Hex End) with associated permissions (RWX).\n"
		"        If the function results false, no output will be written. \n"
		"        If results true, the output will be written to the stream.\n"
		"\n"
		""},
	 { "SBMemoryRegionInfo___repr__", _wrap_SBMemoryRegionInfo___repr__, METH_O, "SBMemoryRegionInfo___repr__(SBMemoryRegionInfo self) -> std::string"},
	 { "SBMemoryRegionInfo_swigregister", SBMemoryRegionInfo_swigregister, METH_O, NULL},
	 { "SBMemoryRegionInfo_swiginit", SBMemoryRegionInfo_swiginit, METH_VARARGS, NULL},
	 { "new_SBMemoryRegionInfoList", _wrap_new_SBMemoryRegionInfoList, METH_VARARGS, "\n"
		"SBMemoryRegionInfoList()\n"
		"new_SBMemoryRegionInfoList(SBMemoryRegionInfoList rhs) -> SBMemoryRegionInfoList\n"
		""},
	 { "delete_SBMemoryRegionInfoList", _wrap_delete_SBMemoryRegionInfoList, METH_O, "delete_SBMemoryRegionInfoList(SBMemoryRegionInfoList self)"},
	 { "SBMemoryRegionInfoList_GetSize", _wrap_SBMemoryRegionInfoList_GetSize, METH_O, "SBMemoryRegionInfoList_GetSize(SBMemoryRegionInfoList self) -> uint32_t"},
	 { "SBMemoryRegionInfoList_GetMemoryRegionContainingAddress", _wrap_SBMemoryRegionInfoList_GetMemoryRegionContainingAddress, METH_VARARGS, "SBMemoryRegionInfoList_GetMemoryRegionContainingAddress(SBMemoryRegionInfoList self, lldb::addr_t addr, SBMemoryRegionInfo region_info) -> bool"},
	 { "SBMemoryRegionInfoList_GetMemoryRegionAtIndex", _wrap_SBMemoryRegionInfoList_GetMemoryRegionAtIndex, METH_VARARGS, "SBMemoryRegionInfoList_GetMemoryRegionAtIndex(SBMemoryRegionInfoList self, uint32_t idx, SBMemoryRegionInfo region_info) -> bool"},
	 { "SBMemoryRegionInfoList_Append", _wrap_SBMemoryRegionInfoList_Append, METH_VARARGS, "\n"
		"SBMemoryRegionInfoList_Append(SBMemoryRegionInfoList self, SBMemoryRegionInfo region)\n"
		"SBMemoryRegionInfoList_Append(SBMemoryRegionInfoList self, SBMemoryRegionInfoList region_list)\n"
		""},
	 { "SBMemoryRegionInfoList_Clear", _wrap_SBMemoryRegionInfoList_Clear, METH_O, "SBMemoryRegionInfoList_Clear(SBMemoryRegionInfoList self)"},
	 { "SBMemoryRegionInfoList_swigregister", SBMemoryRegionInfoList_swigregister, METH_O, NULL},
	 { "SBMemoryRegionInfoList_swiginit", SBMemoryRegionInfoList_swiginit, METH_VARARGS, NULL},
	 { "new_SBModule", _wrap_new_SBModule, METH_VARARGS, "\n"
		"SBModule()\n"
		"SBModule(SBModule rhs)\n"
		"SBModule(SBModuleSpec module_spec)\n"
		"new_SBModule(SBProcess process, lldb::addr_t header_addr) -> SBModule\n"
		""},
	 { "delete_SBModule", _wrap_delete_SBModule, METH_O, "delete_SBModule(SBModule self)"},
	 { "SBModule___nonzero__", _wrap_SBModule___nonzero__, METH_O, "SBModule___nonzero__(SBModule self) -> bool"},
	 { "SBModule_IsValid", _wrap_SBModule_IsValid, METH_O, "SBModule_IsValid(SBModule self) -> bool"},
	 { "SBModule_Clear", _wrap_SBModule_Clear, METH_O, "SBModule_Clear(SBModule self)"},
	 { "SBModule_IsFileBacked", _wrap_SBModule_IsFileBacked, METH_O, "\n"
		"SBModule_IsFileBacked(SBModule self) -> bool\n"
		"\n"
		"    Check if the module is file backed.\n"
		"\n"
		"    @return\n"
		"\n"
		"        True, if the module is backed by an object file on disk.\n"
		"        False, if the module is backed by an object file in memory.\n"
		""},
	 { "SBModule_GetFileSpec", _wrap_SBModule_GetFileSpec, METH_O, "\n"
		"SBModule_GetFileSpec(SBModule self) -> SBFileSpec\n"
		"\n"
		"    Get const accessor for the module file specification.\n"
		"\n"
		"    This function returns the file for the module on the host system\n"
		"    that is running LLDB. This can differ from the path on the\n"
		"    platform since we might be doing remote debugging.\n"
		"\n"
		"    @return\n"
		"        A const reference to the file specification object.\n"
		""},
	 { "SBModule_GetPlatformFileSpec", _wrap_SBModule_GetPlatformFileSpec, METH_O, "\n"
		"SBModule_GetPlatformFileSpec(SBModule self) -> SBFileSpec\n"
		"\n"
		"    Get accessor for the module platform file specification.\n"
		"\n"
		"    Platform file refers to the path of the module as it is known on\n"
		"    the remote system on which it is being debugged. For local\n"
		"    debugging this is always the same as Module::GetFileSpec(). But\n"
		"    remote debugging might mention a file '/usr/lib/liba.dylib'\n"
		"    which might be locally downloaded and cached. In this case the\n"
		"    platform file could be something like:\n"
		"    '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib'\n"
		"    The file could also be cached in a local developer kit directory.\n"
		"\n"
		"    @return\n"
		"        A const reference to the file specification object.\n"
		""},
	 { "SBModule_SetPlatformFileSpec", _wrap_SBModule_SetPlatformFileSpec, METH_VARARGS, "SBModule_SetPlatformFileSpec(SBModule self, SBFileSpec platform_file) -> bool"},
	 { "SBModule_GetRemoteInstallFileSpec", _wrap_SBModule_GetRemoteInstallFileSpec, METH_O, "\n"
		"Get accessor for the remote install path for a module.\n"
		"\n"
		"When debugging to a remote platform by connecting to a remote\n"
		"platform, the install path of the module can be set. If the\n"
		"install path is set, every time the process is about to launch\n"
		"the target will install this module on the remote platform prior\n"
		"to launching.\n"
		"\n"
		":rtype: :py:class:`SBFileSpec`\n"
		":return: \n"
		"        A file specification object.\n"
		""},
	 { "SBModule_SetRemoteInstallFileSpec", _wrap_SBModule_SetRemoteInstallFileSpec, METH_VARARGS, "\n"
		"Set accessor for the remote install path for a module.\n"
		"\n"
		"When debugging to a remote platform by connecting to a remote\n"
		"platform, the install path of the module can be set. If the\n"
		"install path is set, every time the process is about to launch\n"
		"the target will install this module on the remote platform prior\n"
		"to launching.\n"
		"\n"
		"If *file* specifies a full path to an install location, the\n"
		"module will be installed to this path. If the path is relative\n"
		"(no directory specified, or the path is partial like \"usr/lib\"\n"
		"or \"./usr/lib\", then the install path will be resolved using\n"
		"the platform's current working directory as the base path.\n"
		"\n"
		":type file: :py:class:`SBFileSpec`, in\n"
		":param file:\n"
		"        A file specification object.\n"
		""},
	 { "SBModule_GetByteOrder", _wrap_SBModule_GetByteOrder, METH_O, "SBModule_GetByteOrder(SBModule self) -> lldb::ByteOrder"},
	 { "SBModule_GetAddressByteSize", _wrap_SBModule_GetAddressByteSize, METH_O, "SBModule_GetAddressByteSize(SBModule self) -> uint32_t"},
	 { "SBModule_GetTriple", _wrap_SBModule_GetTriple, METH_O, "SBModule_GetTriple(SBModule self) -> char const *"},
	 { "SBModule_GetUUIDBytes", _wrap_SBModule_GetUUIDBytes, METH_O, "SBModule_GetUUIDBytes(SBModule self) -> uint8_t const *"},
	 { "SBModule_GetUUIDString", _wrap_SBModule_GetUUIDString, METH_O, "\n"
		"SBModule_GetUUIDString(SBModule self) -> char const *\n"
		"Returns the UUID of the module as a Python string.\n"
		""},
	 { "SBModule___eq__", _wrap_SBModule___eq__, METH_VARARGS, "SBModule___eq__(SBModule self, SBModule rhs) -> bool"},
	 { "SBModule___ne__", _wrap_SBModule___ne__, METH_VARARGS, "SBModule___ne__(SBModule self, SBModule rhs) -> bool"},
	 { "SBModule_FindSection", _wrap_SBModule_FindSection, METH_VARARGS, "SBModule_FindSection(SBModule self, char const * sect_name) -> SBSection"},
	 { "SBModule_ResolveFileAddress", _wrap_SBModule_ResolveFileAddress, METH_VARARGS, "SBModule_ResolveFileAddress(SBModule self, lldb::addr_t vm_addr) -> SBAddress"},
	 { "SBModule_ResolveSymbolContextForAddress", _wrap_SBModule_ResolveSymbolContextForAddress, METH_VARARGS, "SBModule_ResolveSymbolContextForAddress(SBModule self, SBAddress addr, uint32_t resolve_scope) -> SBSymbolContext"},
	 { "SBModule_GetDescription", _wrap_SBModule_GetDescription, METH_VARARGS, "SBModule_GetDescription(SBModule self, SBStream description) -> bool"},
	 { "SBModule_GetNumCompileUnits", _wrap_SBModule_GetNumCompileUnits, METH_O, "SBModule_GetNumCompileUnits(SBModule self) -> uint32_t"},
	 { "SBModule_GetCompileUnitAtIndex", _wrap_SBModule_GetCompileUnitAtIndex, METH_VARARGS, "SBModule_GetCompileUnitAtIndex(SBModule self, uint32_t arg2) -> SBCompileUnit"},
	 { "SBModule_FindCompileUnits", _wrap_SBModule_FindCompileUnits, METH_VARARGS, "\n"
		"SBModule_FindCompileUnits(SBModule self, SBFileSpec sb_file_spec) -> SBSymbolContextList\n"
		"\n"
		"    Find compile units related to this module and passed source\n"
		"    file.\n"
		"\n"
		"    @param[in] sb_file_spec\n"
		"        A :py:class:`SBFileSpec` object that contains source file\n"
		"        specification.\n"
		"\n"
		"    @return\n"
		"        A :py:class:`SBSymbolContextList` that gets filled in with all of\n"
		"        the symbol contexts for all the matches.\n"
		""},
	 { "SBModule_GetNumSymbols", _wrap_SBModule_GetNumSymbols, METH_O, "SBModule_GetNumSymbols(SBModule self) -> size_t"},
	 { "SBModule_GetSymbolAtIndex", _wrap_SBModule_GetSymbolAtIndex, METH_VARARGS, "SBModule_GetSymbolAtIndex(SBModule self, size_t idx) -> SBSymbol"},
	 { "SBModule_FindSymbol", _wrap_SBModule_FindSymbol, METH_VARARGS, "SBModule_FindSymbol(SBModule self, char const * name, lldb::SymbolType type=eSymbolTypeAny) -> SBSymbol"},
	 { "SBModule_FindSymbols", _wrap_SBModule_FindSymbols, METH_VARARGS, "SBModule_FindSymbols(SBModule self, char const * name, lldb::SymbolType type=eSymbolTypeAny) -> SBSymbolContextList"},
	 { "SBModule_GetNumSections", _wrap_SBModule_GetNumSections, METH_O, "SBModule_GetNumSections(SBModule self) -> size_t"},
	 { "SBModule_GetSectionAtIndex", _wrap_SBModule_GetSectionAtIndex, METH_VARARGS, "SBModule_GetSectionAtIndex(SBModule self, size_t idx) -> SBSection"},
	 { "SBModule_FindFunctions", _wrap_SBModule_FindFunctions, METH_VARARGS, "\n"
		"SBModule_FindFunctions(SBModule self, char const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> SBSymbolContextList\n"
		"\n"
		"    Find functions by name.\n"
		"\n"
		"    @param[in] name\n"
		"        The name of the function we are looking for.\n"
		"\n"
		"    @param[in] name_type_mask\n"
		"        A logical OR of one or more FunctionNameType enum bits that\n"
		"        indicate what kind of names should be used when doing the\n"
		"        lookup. Bits include fully qualified names, base names,\n"
		"        C++ methods, or ObjC selectors.\n"
		"        See FunctionNameType for more details.\n"
		"\n"
		"    @return\n"
		"        A symbol context list that gets filled in with all of the\n"
		"        matches.\n"
		""},
	 { "SBModule_FindGlobalVariables", _wrap_SBModule_FindGlobalVariables, METH_VARARGS, "\n"
		"SBModule_FindGlobalVariables(SBModule self, SBTarget target, char const * name, uint32_t max_matches) -> SBValueList\n"
		"\n"
		"    Find global and static variables by name.\n"
		"\n"
		"    @param[in] target\n"
		"        A valid SBTarget instance representing the debuggee.\n"
		"\n"
		"    @param[in] name\n"
		"        The name of the global or static variable we are looking\n"
		"        for.\n"
		"\n"
		"    @param[in] max_matches\n"
		"        Allow the number of matches to be limited to max_matches.\n"
		"\n"
		"    @return\n"
		"        A list of matched variables in an SBValueList.\n"
		""},
	 { "SBModule_FindFirstGlobalVariable", _wrap_SBModule_FindFirstGlobalVariable, METH_VARARGS, "\n"
		"SBModule_FindFirstGlobalVariable(SBModule self, SBTarget target, char const * name) -> SBValue\n"
		"\n"
		"    Find the first global (or static) variable by name.\n"
		"\n"
		"    @param[in] target\n"
		"        A valid SBTarget instance representing the debuggee.\n"
		"\n"
		"    @param[in] name\n"
		"        The name of the global or static variable we are looking\n"
		"        for.\n"
		"\n"
		"    @return\n"
		"        An SBValue that gets filled in with the found variable (if any).\n"
		""},
	 { "SBModule_FindFirstType", _wrap_SBModule_FindFirstType, METH_VARARGS, "SBModule_FindFirstType(SBModule self, char const * name) -> SBType"},
	 { "SBModule_FindTypes", _wrap_SBModule_FindTypes, METH_VARARGS, "SBModule_FindTypes(SBModule self, char const * type) -> SBTypeList"},
	 { "SBModule_GetTypeByID", _wrap_SBModule_GetTypeByID, METH_VARARGS, "\n"
		"Get a type using its type ID.\n"
		"\n"
		"Each symbol file reader will assign different user IDs to their\n"
		"types, but it is sometimes useful when debugging type issues to\n"
		"be able to grab a type using its type ID.\n"
		"\n"
		"For DWARF debug info, the type ID is the DIE offset.\n"
		"\n"
		":type uid: int, in\n"
		":param uid:\n"
		"        The type user ID.\n"
		"\n"
		":rtype: :py:class:`SBType`\n"
		":return: \n"
		"        An SBType for the given type ID, or an empty SBType if the\n"
		"        type was not found.\n"
		""},
	 { "SBModule_GetBasicType", _wrap_SBModule_GetBasicType, METH_VARARGS, "SBModule_GetBasicType(SBModule self, lldb::BasicType type) -> SBType"},
	 { "SBModule_GetTypes", _wrap_SBModule_GetTypes, METH_VARARGS, "\n"
		"SBModule_GetTypes(SBModule self, uint32_t type_mask=eTypeClassAny) -> SBTypeList\n"
		"\n"
		"    Get all types matching type_mask from debug info in this\n"
		"    module.\n"
		"\n"
		"    @param[in] type_mask\n"
		"        A bitfield that consists of one or more bits logically OR'ed\n"
		"        together from the lldb::TypeClass enumeration. This allows\n"
		"        you to request only structure types, or only class, struct\n"
		"        and union types. Passing in lldb::eTypeClassAny will return\n"
		"        all types found in the debug information for this module.\n"
		"\n"
		"    @return\n"
		"        A list of types in this module that match type_mask\n"
		""},
	 { "SBModule_GetVersion", _wrap_SBModule_GetVersion, METH_O, "\n"
		"Get the module version numbers.\n"
		"\n"
		"Many object files have a set of version numbers that describe\n"
		"the version of the executable or shared library. Typically there\n"
		"are major, minor and build, but there may be more. This function\n"
		"will extract the versions from object files if they are available.\n"
		"\n"
		"If *versions* is NULL, or if *num_versions* is 0, the return\n"
		"value will indicate how many version numbers are available in\n"
		"this object file. Then a subsequent call can be made to this\n"
		"function with a value of *versions* and *num_versions* that\n"
		"has enough storage to store some or all version numbers.\n"
		"\n"
		":type versions: int, out\n"
		":param versions:\n"
		"        A pointer to an array of uint32_t types that is *num_versions*\n"
		"        long. If this value is NULL, the return value will indicate\n"
		"        how many version numbers are required for a subsequent call\n"
		"        to this function so that all versions can be retrieved. If\n"
		"        the value is non-NULL, then at most *num_versions* of the\n"
		"        existing versions numbers will be filled into *versions*.\n"
		"        If there is no version information available, *versions*\n"
		"        will be filled with *num_versions* UINT32_MAX values\n"
		"        and zero will be returned.\n"
		"\n"
		":type num_versions: int, in\n"
		":param num_versions:\n"
		"        The maximum number of entries to fill into *versions*. If\n"
		"        this value is zero, then the return value will indicate\n"
		"        how many version numbers there are in total so another call\n"
		"        to this function can be make with adequate storage in\n"
		"        *versions* to get all of the version numbers. If\n"
		"   *num_versions* is less than the actual number of version\n"
		"        numbers in this object file, only *num_versions* will be\n"
		"        filled into *versions* (if *versions* is non-NULL).\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"        This function always returns the number of version numbers\n"
		"        that this object file has regardless of the number of\n"
		"        version numbers that were copied into *versions*.\n"
		""},
	 { "SBModule_GetSymbolFileSpec", _wrap_SBModule_GetSymbolFileSpec, METH_O, "\n"
		"Get accessor for the symbol file specification.\n"
		"\n"
		"When debugging an object file an additional debug information can\n"
		"be provided in separate file. Therefore if you debugging something\n"
		"like '/usr/lib/liba.dylib' then debug information can be located\n"
		"in folder like '/usr/lib/liba.dylib.dSYM/'.\n"
		"\n"
		":rtype: :py:class:`SBFileSpec`\n"
		":return: \n"
		"        A const reference to the file specification object.\n"
		""},
	 { "SBModule_GetObjectFileHeaderAddress", _wrap_SBModule_GetObjectFileHeaderAddress, METH_O, "SBModule_GetObjectFileHeaderAddress(SBModule self) -> SBAddress"},
	 { "SBModule_GetObjectFileEntryPointAddress", _wrap_SBModule_GetObjectFileEntryPointAddress, METH_O, "SBModule_GetObjectFileEntryPointAddress(SBModule self) -> SBAddress"},
	 { "SBModule_GetNumberAllocatedModules", _wrap_SBModule_GetNumberAllocatedModules, METH_NOARGS, "\n"
		"SBModule_GetNumberAllocatedModules() -> uint32_t\n"
		"\n"
		"    Returns the number of modules in the module cache. This is an\n"
		"    implementation detail exposed for testing and should not be relied upon.\n"
		"\n"
		"    @return\n"
		"        The number of modules in the module cache.\n"
		""},
	 { "SBModule_GarbageCollectAllocatedModules", _wrap_SBModule_GarbageCollectAllocatedModules, METH_NOARGS, "\n"
		"SBModule_GarbageCollectAllocatedModules()\n"
		"\n"
		"    Removes all modules which are no longer needed by any part of LLDB from\n"
		"    the module cache.\n"
		"\n"
		"    This is an implementation detail exposed for testing and should not be\n"
		"    relied upon. Use SBDebugger::MemoryPressureDetected instead to reduce\n"
		"    LLDB's memory consumption during execution.\n"
		"\n"
		""},
	 { "SBModule_GetObjectName", _wrap_SBModule_GetObjectName, METH_O, "\n"
		"If this Module represents a specific object or part within a larger file,\n"
		"returns the name of that object or part. Otherwise, returns\n"
		"nullptr.\n"
		""},
	 { "SBModule___repr__", _wrap_SBModule___repr__, METH_O, "SBModule___repr__(SBModule self) -> std::string"},
	 { "SBModule_swigregister", SBModule_swigregister, METH_O, NULL},
	 { "SBModule_swiginit", SBModule_swiginit, METH_VARARGS, NULL},
	 { "new_SBModuleSpec", _wrap_new_SBModuleSpec, METH_VARARGS, "\n"
		"SBModuleSpec()\n"
		"new_SBModuleSpec(SBModuleSpec rhs) -> SBModuleSpec\n"
		""},
	 { "delete_SBModuleSpec", _wrap_delete_SBModuleSpec, METH_O, "delete_SBModuleSpec(SBModuleSpec self)"},
	 { "SBModuleSpec___nonzero__", _wrap_SBModuleSpec___nonzero__, METH_O, "SBModuleSpec___nonzero__(SBModuleSpec self) -> bool"},
	 { "SBModuleSpec_IsValid", _wrap_SBModuleSpec_IsValid, METH_O, "SBModuleSpec_IsValid(SBModuleSpec self) -> bool"},
	 { "SBModuleSpec_Clear", _wrap_SBModuleSpec_Clear, METH_O, "SBModuleSpec_Clear(SBModuleSpec self)"},
	 { "SBModuleSpec_GetFileSpec", _wrap_SBModuleSpec_GetFileSpec, METH_O, "\n"
		"SBModuleSpec_GetFileSpec(SBModuleSpec self) -> SBFileSpec\n"
		"\n"
		"    Get const accessor for the module file.\n"
		"\n"
		"    This function returns the file for the module on the host system\n"
		"    that is running LLDB. This can differ from the path on the\n"
		"    platform since we might be doing remote debugging.\n"
		"\n"
		"    @return\n"
		"        A const reference to the file specification object.\n"
		""},
	 { "SBModuleSpec_SetFileSpec", _wrap_SBModuleSpec_SetFileSpec, METH_VARARGS, "SBModuleSpec_SetFileSpec(SBModuleSpec self, SBFileSpec fspec)"},
	 { "SBModuleSpec_GetPlatformFileSpec", _wrap_SBModuleSpec_GetPlatformFileSpec, METH_O, "\n"
		"SBModuleSpec_GetPlatformFileSpec(SBModuleSpec self) -> SBFileSpec\n"
		"\n"
		"    Get accessor for the module platform file.\n"
		"\n"
		"    Platform file refers to the path of the module as it is known on\n"
		"    the remote system on which it is being debugged. For local\n"
		"    debugging this is always the same as Module::GetFileSpec(). But\n"
		"    remote debugging might mention a file '/usr/lib/liba.dylib'\n"
		"    which might be locally downloaded and cached. In this case the\n"
		"    platform file could be something like:\n"
		"    '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib'\n"
		"    The file could also be cached in a local developer kit directory.\n"
		"\n"
		"    @return\n"
		"        A const reference to the file specification object.\n"
		""},
	 { "SBModuleSpec_SetPlatformFileSpec", _wrap_SBModuleSpec_SetPlatformFileSpec, METH_VARARGS, "SBModuleSpec_SetPlatformFileSpec(SBModuleSpec self, SBFileSpec fspec)"},
	 { "SBModuleSpec_GetSymbolFileSpec", _wrap_SBModuleSpec_GetSymbolFileSpec, METH_O, "SBModuleSpec_GetSymbolFileSpec(SBModuleSpec self) -> SBFileSpec"},
	 { "SBModuleSpec_SetSymbolFileSpec", _wrap_SBModuleSpec_SetSymbolFileSpec, METH_VARARGS, "SBModuleSpec_SetSymbolFileSpec(SBModuleSpec self, SBFileSpec fspec)"},
	 { "SBModuleSpec_GetObjectName", _wrap_SBModuleSpec_GetObjectName, METH_O, "SBModuleSpec_GetObjectName(SBModuleSpec self) -> char const *"},
	 { "SBModuleSpec_SetObjectName", _wrap_SBModuleSpec_SetObjectName, METH_VARARGS, "SBModuleSpec_SetObjectName(SBModuleSpec self, char const * name)"},
	 { "SBModuleSpec_GetTriple", _wrap_SBModuleSpec_GetTriple, METH_O, "SBModuleSpec_GetTriple(SBModuleSpec self) -> char const *"},
	 { "SBModuleSpec_SetTriple", _wrap_SBModuleSpec_SetTriple, METH_VARARGS, "SBModuleSpec_SetTriple(SBModuleSpec self, char const * triple)"},
	 { "SBModuleSpec_GetUUIDBytes", _wrap_SBModuleSpec_GetUUIDBytes, METH_O, "SBModuleSpec_GetUUIDBytes(SBModuleSpec self) -> uint8_t const *"},
	 { "SBModuleSpec_GetUUIDLength", _wrap_SBModuleSpec_GetUUIDLength, METH_O, "SBModuleSpec_GetUUIDLength(SBModuleSpec self) -> size_t"},
	 { "SBModuleSpec_SetUUIDBytes", _wrap_SBModuleSpec_SetUUIDBytes, METH_VARARGS, "SBModuleSpec_SetUUIDBytes(SBModuleSpec self, uint8_t const * uuid, size_t uuid_len) -> bool"},
	 { "SBModuleSpec_GetObjectOffset", _wrap_SBModuleSpec_GetObjectOffset, METH_O, "SBModuleSpec_GetObjectOffset(SBModuleSpec self) -> uint64_t"},
	 { "SBModuleSpec_SetObjectOffset", _wrap_SBModuleSpec_SetObjectOffset, METH_VARARGS, "SBModuleSpec_SetObjectOffset(SBModuleSpec self, uint64_t object_offset)"},
	 { "SBModuleSpec_GetObjectSize", _wrap_SBModuleSpec_GetObjectSize, METH_O, "SBModuleSpec_GetObjectSize(SBModuleSpec self) -> uint64_t"},
	 { "SBModuleSpec_SetObjectSize", _wrap_SBModuleSpec_SetObjectSize, METH_VARARGS, "SBModuleSpec_SetObjectSize(SBModuleSpec self, uint64_t object_size)"},
	 { "SBModuleSpec_GetDescription", _wrap_SBModuleSpec_GetDescription, METH_VARARGS, "SBModuleSpec_GetDescription(SBModuleSpec self, SBStream description) -> bool"},
	 { "SBModuleSpec_GetTarget", _wrap_SBModuleSpec_GetTarget, METH_O, "SBModuleSpec_GetTarget(SBModuleSpec self) -> SBTarget"},
	 { "SBModuleSpec_SetTarget", _wrap_SBModuleSpec_SetTarget, METH_VARARGS, "\n"
		"Set the target to be used when resolving a module.\n"
		"\n"
		"A target can help locate a module specified by a SBModuleSpec. The\n"
		"target settings, like the executable and debug info search paths, can\n"
		"be essential. The target's platform can also be used to locate or download\n"
		"the specified module.\n"
		""},
	 { "SBModuleSpec___repr__", _wrap_SBModuleSpec___repr__, METH_O, "SBModuleSpec___repr__(SBModuleSpec self) -> std::string"},
	 { "SBModuleSpec_swigregister", SBModuleSpec_swigregister, METH_O, NULL},
	 { "SBModuleSpec_swiginit", SBModuleSpec_swiginit, METH_VARARGS, NULL},
	 { "new_SBModuleSpecList", _wrap_new_SBModuleSpecList, METH_VARARGS, "\n"
		"SBModuleSpecList()\n"
		"new_SBModuleSpecList(SBModuleSpecList rhs) -> SBModuleSpecList\n"
		""},
	 { "delete_SBModuleSpecList", _wrap_delete_SBModuleSpecList, METH_O, "delete_SBModuleSpecList(SBModuleSpecList self)"},
	 { "SBModuleSpecList_GetModuleSpecifications", _wrap_SBModuleSpecList_GetModuleSpecifications, METH_O, "SBModuleSpecList_GetModuleSpecifications(char const * path) -> SBModuleSpecList"},
	 { "SBModuleSpecList_Append", _wrap_SBModuleSpecList_Append, METH_VARARGS, "\n"
		"SBModuleSpecList_Append(SBModuleSpecList self, SBModuleSpec spec)\n"
		"SBModuleSpecList_Append(SBModuleSpecList self, SBModuleSpecList spec_list)\n"
		""},
	 { "SBModuleSpecList_FindFirstMatchingSpec", _wrap_SBModuleSpecList_FindFirstMatchingSpec, METH_VARARGS, "SBModuleSpecList_FindFirstMatchingSpec(SBModuleSpecList self, SBModuleSpec match_spec) -> SBModuleSpec"},
	 { "SBModuleSpecList_FindMatchingSpecs", _wrap_SBModuleSpecList_FindMatchingSpecs, METH_VARARGS, "SBModuleSpecList_FindMatchingSpecs(SBModuleSpecList self, SBModuleSpec match_spec) -> SBModuleSpecList"},
	 { "SBModuleSpecList_GetSize", _wrap_SBModuleSpecList_GetSize, METH_O, "SBModuleSpecList_GetSize(SBModuleSpecList self) -> size_t"},
	 { "SBModuleSpecList_GetSpecAtIndex", _wrap_SBModuleSpecList_GetSpecAtIndex, METH_VARARGS, "SBModuleSpecList_GetSpecAtIndex(SBModuleSpecList self, size_t i) -> SBModuleSpec"},
	 { "SBModuleSpecList_GetDescription", _wrap_SBModuleSpecList_GetDescription, METH_VARARGS, "SBModuleSpecList_GetDescription(SBModuleSpecList self, SBStream description) -> bool"},
	 { "SBModuleSpecList___repr__", _wrap_SBModuleSpecList___repr__, METH_O, "SBModuleSpecList___repr__(SBModuleSpecList self) -> std::string"},
	 { "SBModuleSpecList_swigregister", SBModuleSpecList_swigregister, METH_O, NULL},
	 { "SBModuleSpecList_swiginit", SBModuleSpecList_swiginit, METH_VARARGS, NULL},
	 { "new_SBMutex", _wrap_new_SBMutex, METH_VARARGS, "\n"
		"SBMutex()\n"
		"new_SBMutex(SBMutex rhs) -> SBMutex\n"
		""},
	 { "delete_SBMutex", _wrap_delete_SBMutex, METH_O, "delete_SBMutex(SBMutex self)"},
	 { "SBMutex_IsValid", _wrap_SBMutex_IsValid, METH_O, "Returns true if this lock has ownership of the underlying mutex."},
	 { "SBMutex_lock", _wrap_SBMutex_lock, METH_O, "Blocking operation that takes ownership of this lock."},
	 { "SBMutex_unlock", _wrap_SBMutex_unlock, METH_O, "Releases ownership of this lock."},
	 { "SBMutex_try_lock", _wrap_SBMutex_try_lock, METH_O, "\n"
		"Tries to lock the mutex. Returns immediately. On successful lock\n"
		"acquisition returns true, otherwise returns false.\n"
		""},
	 { "SBMutex_swigregister", SBMutex_swigregister, METH_O, NULL},
	 { "SBMutex_swiginit", SBMutex_swiginit, METH_VARARGS, NULL},
	 { "new_SBPlatformConnectOptions", _wrap_new_SBPlatformConnectOptions, METH_VARARGS, "\n"
		"SBPlatformConnectOptions(char const * url)\n"
		"new_SBPlatformConnectOptions(SBPlatformConnectOptions rhs) -> SBPlatformConnectOptions\n"
		""},
	 { "delete_SBPlatformConnectOptions", _wrap_delete_SBPlatformConnectOptions, METH_O, "delete_SBPlatformConnectOptions(SBPlatformConnectOptions self)"},
	 { "SBPlatformConnectOptions_GetURL", _wrap_SBPlatformConnectOptions_GetURL, METH_O, "SBPlatformConnectOptions_GetURL(SBPlatformConnectOptions self) -> char const *"},
	 { "SBPlatformConnectOptions_SetURL", _wrap_SBPlatformConnectOptions_SetURL, METH_VARARGS, "SBPlatformConnectOptions_SetURL(SBPlatformConnectOptions self, char const * url)"},
	 { "SBPlatformConnectOptions_GetRsyncEnabled", _wrap_SBPlatformConnectOptions_GetRsyncEnabled, METH_O, "SBPlatformConnectOptions_GetRsyncEnabled(SBPlatformConnectOptions self) -> bool"},
	 { "SBPlatformConnectOptions_EnableRsync", _wrap_SBPlatformConnectOptions_EnableRsync, METH_VARARGS, "SBPlatformConnectOptions_EnableRsync(SBPlatformConnectOptions self, char const * options, char const * remote_path_prefix, bool omit_remote_hostname)"},
	 { "SBPlatformConnectOptions_DisableRsync", _wrap_SBPlatformConnectOptions_DisableRsync, METH_O, "SBPlatformConnectOptions_DisableRsync(SBPlatformConnectOptions self)"},
	 { "SBPlatformConnectOptions_GetLocalCacheDirectory", _wrap_SBPlatformConnectOptions_GetLocalCacheDirectory, METH_O, "SBPlatformConnectOptions_GetLocalCacheDirectory(SBPlatformConnectOptions self) -> char const *"},
	 { "SBPlatformConnectOptions_SetLocalCacheDirectory", _wrap_SBPlatformConnectOptions_SetLocalCacheDirectory, METH_VARARGS, "SBPlatformConnectOptions_SetLocalCacheDirectory(SBPlatformConnectOptions self, char const * path)"},
	 { "SBPlatformConnectOptions_swigregister", SBPlatformConnectOptions_swigregister, METH_O, NULL},
	 { "SBPlatformConnectOptions_swiginit", SBPlatformConnectOptions_swiginit, METH_VARARGS, NULL},
	 { "new_SBPlatformShellCommand", _wrap_new_SBPlatformShellCommand, METH_VARARGS, "\n"
		"SBPlatformShellCommand(char const * shell, char const * shell_command)\n"
		"SBPlatformShellCommand(char const * shell_command)\n"
		"new_SBPlatformShellCommand(SBPlatformShellCommand rhs) -> SBPlatformShellCommand\n"
		""},
	 { "delete_SBPlatformShellCommand", _wrap_delete_SBPlatformShellCommand, METH_O, "delete_SBPlatformShellCommand(SBPlatformShellCommand self)"},
	 { "SBPlatformShellCommand_Clear", _wrap_SBPlatformShellCommand_Clear, METH_O, "SBPlatformShellCommand_Clear(SBPlatformShellCommand self)"},
	 { "SBPlatformShellCommand_GetShell", _wrap_SBPlatformShellCommand_GetShell, METH_O, "SBPlatformShellCommand_GetShell(SBPlatformShellCommand self) -> char const *"},
	 { "SBPlatformShellCommand_SetShell", _wrap_SBPlatformShellCommand_SetShell, METH_VARARGS, "SBPlatformShellCommand_SetShell(SBPlatformShellCommand self, char const * shell)"},
	 { "SBPlatformShellCommand_GetCommand", _wrap_SBPlatformShellCommand_GetCommand, METH_O, "SBPlatformShellCommand_GetCommand(SBPlatformShellCommand self) -> char const *"},
	 { "SBPlatformShellCommand_SetCommand", _wrap_SBPlatformShellCommand_SetCommand, METH_VARARGS, "SBPlatformShellCommand_SetCommand(SBPlatformShellCommand self, char const * shell_command)"},
	 { "SBPlatformShellCommand_GetWorkingDirectory", _wrap_SBPlatformShellCommand_GetWorkingDirectory, METH_O, "SBPlatformShellCommand_GetWorkingDirectory(SBPlatformShellCommand self) -> char const *"},
	 { "SBPlatformShellCommand_SetWorkingDirectory", _wrap_SBPlatformShellCommand_SetWorkingDirectory, METH_VARARGS, "SBPlatformShellCommand_SetWorkingDirectory(SBPlatformShellCommand self, char const * path)"},
	 { "SBPlatformShellCommand_GetTimeoutSeconds", _wrap_SBPlatformShellCommand_GetTimeoutSeconds, METH_O, "SBPlatformShellCommand_GetTimeoutSeconds(SBPlatformShellCommand self) -> uint32_t"},
	 { "SBPlatformShellCommand_SetTimeoutSeconds", _wrap_SBPlatformShellCommand_SetTimeoutSeconds, METH_VARARGS, "SBPlatformShellCommand_SetTimeoutSeconds(SBPlatformShellCommand self, uint32_t sec)"},
	 { "SBPlatformShellCommand_GetSignal", _wrap_SBPlatformShellCommand_GetSignal, METH_O, "SBPlatformShellCommand_GetSignal(SBPlatformShellCommand self) -> int"},
	 { "SBPlatformShellCommand_GetStatus", _wrap_SBPlatformShellCommand_GetStatus, METH_O, "SBPlatformShellCommand_GetStatus(SBPlatformShellCommand self) -> int"},
	 { "SBPlatformShellCommand_GetOutput", _wrap_SBPlatformShellCommand_GetOutput, METH_O, "SBPlatformShellCommand_GetOutput(SBPlatformShellCommand self) -> char const *"},
	 { "SBPlatformShellCommand_swigregister", SBPlatformShellCommand_swigregister, METH_O, NULL},
	 { "SBPlatformShellCommand_swiginit", SBPlatformShellCommand_swiginit, METH_VARARGS, NULL},
	 { "new_SBPlatform", _wrap_new_SBPlatform, METH_VARARGS, "\n"
		"SBPlatform()\n"
		"SBPlatform(char const * platform_name)\n"
		"new_SBPlatform(SBPlatform rhs) -> SBPlatform\n"
		""},
	 { "delete_SBPlatform", _wrap_delete_SBPlatform, METH_O, "delete_SBPlatform(SBPlatform self)"},
	 { "SBPlatform_GetHostPlatform", _wrap_SBPlatform_GetHostPlatform, METH_NOARGS, "SBPlatform_GetHostPlatform() -> SBPlatform"},
	 { "SBPlatform___nonzero__", _wrap_SBPlatform___nonzero__, METH_O, "SBPlatform___nonzero__(SBPlatform self) -> bool"},
	 { "SBPlatform_IsValid", _wrap_SBPlatform_IsValid, METH_O, "SBPlatform_IsValid(SBPlatform self) -> bool"},
	 { "SBPlatform_IsHost", _wrap_SBPlatform_IsHost, METH_O, "Returns true if this platform is the host platform, otherwise false."},
	 { "SBPlatform_Clear", _wrap_SBPlatform_Clear, METH_O, "SBPlatform_Clear(SBPlatform self)"},
	 { "SBPlatform_GetWorkingDirectory", _wrap_SBPlatform_GetWorkingDirectory, METH_O, "SBPlatform_GetWorkingDirectory(SBPlatform self) -> char const *"},
	 { "SBPlatform_SetWorkingDirectory", _wrap_SBPlatform_SetWorkingDirectory, METH_VARARGS, "SBPlatform_SetWorkingDirectory(SBPlatform self, char const * path) -> bool"},
	 { "SBPlatform_GetName", _wrap_SBPlatform_GetName, METH_O, "SBPlatform_GetName(SBPlatform self) -> char const *"},
	 { "SBPlatform_ConnectRemote", _wrap_SBPlatform_ConnectRemote, METH_VARARGS, "SBPlatform_ConnectRemote(SBPlatform self, SBPlatformConnectOptions connect_options) -> SBError"},
	 { "SBPlatform_DisconnectRemote", _wrap_SBPlatform_DisconnectRemote, METH_O, "SBPlatform_DisconnectRemote(SBPlatform self)"},
	 { "SBPlatform_IsConnected", _wrap_SBPlatform_IsConnected, METH_O, "SBPlatform_IsConnected(SBPlatform self) -> bool"},
	 { "SBPlatform_GetTriple", _wrap_SBPlatform_GetTriple, METH_O, "SBPlatform_GetTriple(SBPlatform self) -> char const *"},
	 { "SBPlatform_GetHostname", _wrap_SBPlatform_GetHostname, METH_O, "SBPlatform_GetHostname(SBPlatform self) -> char const *"},
	 { "SBPlatform_GetOSBuild", _wrap_SBPlatform_GetOSBuild, METH_O, "SBPlatform_GetOSBuild(SBPlatform self) -> char const *"},
	 { "SBPlatform_GetOSDescription", _wrap_SBPlatform_GetOSDescription, METH_O, "SBPlatform_GetOSDescription(SBPlatform self) -> char const *"},
	 { "SBPlatform_GetOSMajorVersion", _wrap_SBPlatform_GetOSMajorVersion, METH_O, "SBPlatform_GetOSMajorVersion(SBPlatform self) -> uint32_t"},
	 { "SBPlatform_GetOSMinorVersion", _wrap_SBPlatform_GetOSMinorVersion, METH_O, "SBPlatform_GetOSMinorVersion(SBPlatform self) -> uint32_t"},
	 { "SBPlatform_GetOSUpdateVersion", _wrap_SBPlatform_GetOSUpdateVersion, METH_O, "SBPlatform_GetOSUpdateVersion(SBPlatform self) -> uint32_t"},
	 { "SBPlatform_SetSDKRoot", _wrap_SBPlatform_SetSDKRoot, METH_VARARGS, "SBPlatform_SetSDKRoot(SBPlatform self, char const * sysroot)"},
	 { "SBPlatform_Put", _wrap_SBPlatform_Put, METH_VARARGS, "SBPlatform_Put(SBPlatform self, SBFileSpec src, SBFileSpec dst) -> SBError"},
	 { "SBPlatform_Get", _wrap_SBPlatform_Get, METH_VARARGS, "SBPlatform_Get(SBPlatform self, SBFileSpec src, SBFileSpec dst) -> SBError"},
	 { "SBPlatform_Install", _wrap_SBPlatform_Install, METH_VARARGS, "SBPlatform_Install(SBPlatform self, SBFileSpec src, SBFileSpec dst) -> SBError"},
	 { "SBPlatform_Run", _wrap_SBPlatform_Run, METH_VARARGS, "SBPlatform_Run(SBPlatform self, SBPlatformShellCommand shell_command) -> SBError"},
	 { "SBPlatform_Launch", _wrap_SBPlatform_Launch, METH_VARARGS, "SBPlatform_Launch(SBPlatform self, SBLaunchInfo launch_info) -> SBError"},
	 { "SBPlatform_Attach", _wrap_SBPlatform_Attach, METH_VARARGS, "SBPlatform_Attach(SBPlatform self, SBAttachInfo attach_info, SBDebugger debugger, SBTarget target, SBError error) -> SBProcess"},
	 { "SBPlatform_GetAllProcesses", _wrap_SBPlatform_GetAllProcesses, METH_VARARGS, "SBPlatform_GetAllProcesses(SBPlatform self, SBError error) -> SBProcessInfoList"},
	 { "SBPlatform_Kill", _wrap_SBPlatform_Kill, METH_VARARGS, "SBPlatform_Kill(SBPlatform self, lldb::pid_t const pid) -> SBError"},
	 { "SBPlatform_MakeDirectory", _wrap_SBPlatform_MakeDirectory, METH_VARARGS, "SBPlatform_MakeDirectory(SBPlatform self, char const * path, uint32_t file_permissions=eFilePermissionsDirectoryDefault) -> SBError"},
	 { "SBPlatform_GetFilePermissions", _wrap_SBPlatform_GetFilePermissions, METH_VARARGS, "SBPlatform_GetFilePermissions(SBPlatform self, char const * path) -> uint32_t"},
	 { "SBPlatform_SetFilePermissions", _wrap_SBPlatform_SetFilePermissions, METH_VARARGS, "SBPlatform_SetFilePermissions(SBPlatform self, char const * path, uint32_t file_permissions) -> SBError"},
	 { "SBPlatform_GetUnixSignals", _wrap_SBPlatform_GetUnixSignals, METH_O, "SBPlatform_GetUnixSignals(SBPlatform self) -> SBUnixSignals"},
	 { "SBPlatform_GetEnvironment", _wrap_SBPlatform_GetEnvironment, METH_O, "\n"
		"Return the environment variables of the remote platform connection\n"
		"process.\n"
		"\n"
		":rtype: :py:class:`SBEnvironment`\n"
		":return: \n"
		"        An lldb::SBEnvironment object which is a copy of the platform's\n"
		"        environment.\n"
		""},
	 { "SBPlatform_SetLocateModuleCallback", _wrap_SBPlatform_SetLocateModuleCallback, METH_VARARGS, "\n"
		"Set a callback as an implementation for locating module in order to\n"
		"implement own module cache system. For example, to leverage distributed\n"
		"build system, to bypass pulling files from remote platform, or to search\n"
		"symbol files from symbol servers. The target will call this callback to\n"
		"get a module file and a symbol file, and it will fallback to the LLDB\n"
		"implementation when this callback failed or returned non-existent file.\n"
		"This callback can set either module_file_spec or symbol_file_spec, or both\n"
		"module_file_spec and symbol_file_spec. The callback will be cleared if\n"
		"nullptr or None is set.\n"
		""},
	 { "SBPlatform_swigregister", SBPlatform_swigregister, METH_O, NULL},
	 { "SBPlatform_swiginit", SBPlatform_swiginit, METH_VARARGS, NULL},
	 { "new_SBProcess", _wrap_new_SBProcess, METH_VARARGS, "\n"
		"SBProcess()\n"
		"new_SBProcess(SBProcess rhs) -> SBProcess\n"
		""},
	 { "delete_SBProcess", _wrap_delete_SBProcess, METH_O, "delete_SBProcess(SBProcess self)"},
	 { "SBProcess_GetBroadcasterClassName", _wrap_SBProcess_GetBroadcasterClassName, METH_NOARGS, "SBProcess_GetBroadcasterClassName() -> char const *"},
	 { "SBProcess_GetPluginName", _wrap_SBProcess_GetPluginName, METH_O, "SBProcess_GetPluginName(SBProcess self) -> char const *"},
	 { "SBProcess_GetShortPluginName", _wrap_SBProcess_GetShortPluginName, METH_O, "SBProcess_GetShortPluginName(SBProcess self) -> char const *"},
	 { "SBProcess_Clear", _wrap_SBProcess_Clear, METH_O, "SBProcess_Clear(SBProcess self)"},
	 { "SBProcess___nonzero__", _wrap_SBProcess___nonzero__, METH_O, "SBProcess___nonzero__(SBProcess self) -> bool"},
	 { "SBProcess_IsValid", _wrap_SBProcess_IsValid, METH_O, "SBProcess_IsValid(SBProcess self) -> bool"},
	 { "SBProcess_GetTarget", _wrap_SBProcess_GetTarget, METH_O, "SBProcess_GetTarget(SBProcess self) -> SBTarget"},
	 { "SBProcess_GetByteOrder", _wrap_SBProcess_GetByteOrder, METH_O, "SBProcess_GetByteOrder(SBProcess self) -> lldb::ByteOrder"},
	 { "SBProcess_PutSTDIN", _wrap_SBProcess_PutSTDIN, METH_VARARGS, "\n"
		"SBProcess_PutSTDIN(SBProcess self, char const * src) -> size_t\n"
		"\n"
		"    Writes data into the current process's stdin. API client specifies a Python\n"
		"    string as the only argument.\n"
		""},
	 { "SBProcess_GetSTDOUT", _wrap_SBProcess_GetSTDOUT, METH_VARARGS, "\n"
		"SBProcess_GetSTDOUT(SBProcess self, char * dst) -> size_t\n"
		"\n"
		"    Reads data from the current process's stdout stream. API client specifies\n"
		"    the size of the buffer to read data into. It returns the byte buffer in a\n"
		"    Python string.\n"
		""},
	 { "SBProcess_GetSTDERR", _wrap_SBProcess_GetSTDERR, METH_VARARGS, "\n"
		"SBProcess_GetSTDERR(SBProcess self, char * dst) -> size_t\n"
		"\n"
		"    Reads data from the current process's stderr stream. API client specifies\n"
		"    the size of the buffer to read data into. It returns the byte buffer in a\n"
		"    Python string.\n"
		""},
	 { "SBProcess_GetAsyncProfileData", _wrap_SBProcess_GetAsyncProfileData, METH_VARARGS, "SBProcess_GetAsyncProfileData(SBProcess self, char * dst) -> size_t"},
	 { "SBProcess_ReportEventState", _wrap_SBProcess_ReportEventState, METH_VARARGS, "\n"
		"SBProcess_ReportEventState(SBProcess self, SBEvent event, SBFile file)\n"
		"SBProcess_ReportEventState(SBProcess self, SBEvent event, lldb::FileSP BORROWED)\n"
		""},
	 { "SBProcess_AppendEventStateReport", _wrap_SBProcess_AppendEventStateReport, METH_VARARGS, "SBProcess_AppendEventStateReport(SBProcess self, SBEvent event, SBCommandReturnObject result)"},
	 { "SBProcess_RemoteAttachToProcessWithID", _wrap_SBProcess_RemoteAttachToProcessWithID, METH_VARARGS, "\n"
		"SBProcess_RemoteAttachToProcessWithID(SBProcess self, lldb::pid_t pid, SBError error) -> bool\n"
		"\n"
		"    Remote connection related functions. These will fail if the\n"
		"    process is not in eStateConnected. They are intended for use\n"
		"    when connecting to an externally managed debugserver instance.\n"
		""},
	 { "SBProcess_RemoteLaunch", _wrap_SBProcess_RemoteLaunch, METH_VARARGS, "\n"
		"SBProcess_RemoteLaunch(SBProcess self, char const ** argv, char const ** envp, char const * stdin_path, char const * stdout_path, char const * stderr_path, char const * working_directory, uint32_t launch_flags, bool stop_at_entry, SBError error) -> bool\n"
		"See SBTarget.Launch for argument description and usage.\n"
		""},
	 { "SBProcess_GetNumThreads", _wrap_SBProcess_GetNumThreads, METH_O, "SBProcess_GetNumThreads(SBProcess self) -> uint32_t"},
	 { "SBProcess_GetThreadAtIndex", _wrap_SBProcess_GetThreadAtIndex, METH_VARARGS, "\n"
		"SBProcess_GetThreadAtIndex(SBProcess self, size_t index) -> SBThread\n"
		"\n"
		"    Returns the INDEX'th thread from the list of current threads.  The index\n"
		"    of a thread is only valid for the current stop.  For a persistent thread\n"
		"    identifier use either the thread ID or the IndexID.  See help on SBThread\n"
		"    for more details.\n"
		""},
	 { "SBProcess_GetThreadByID", _wrap_SBProcess_GetThreadByID, METH_VARARGS, "\n"
		"SBProcess_GetThreadByID(SBProcess self, lldb::tid_t sb_thread_id) -> SBThread\n"
		"\n"
		"    Returns the thread with the given thread ID.\n"
		""},
	 { "SBProcess_GetThreadByIndexID", _wrap_SBProcess_GetThreadByIndexID, METH_VARARGS, "\n"
		"SBProcess_GetThreadByIndexID(SBProcess self, uint32_t index_id) -> SBThread\n"
		"\n"
		"    Returns the thread with the given thread IndexID.\n"
		""},
	 { "SBProcess_GetSelectedThread", _wrap_SBProcess_GetSelectedThread, METH_O, "\n"
		"SBProcess_GetSelectedThread(SBProcess self) -> SBThread\n"
		"\n"
		"    Returns the currently selected thread.\n"
		""},
	 { "SBProcess_CreateOSPluginThread", _wrap_SBProcess_CreateOSPluginThread, METH_VARARGS, "\n"
		"SBProcess_CreateOSPluginThread(SBProcess self, lldb::tid_t tid, lldb::addr_t context) -> SBThread\n"
		"\n"
		"    Lazily create a thread on demand through the current OperatingSystem plug-in, if the current OperatingSystem plug-in supports it.\n"
		""},
	 { "SBProcess_SetSelectedThread", _wrap_SBProcess_SetSelectedThread, METH_VARARGS, "SBProcess_SetSelectedThread(SBProcess self, SBThread thread) -> bool"},
	 { "SBProcess_SetSelectedThreadByID", _wrap_SBProcess_SetSelectedThreadByID, METH_VARARGS, "SBProcess_SetSelectedThreadByID(SBProcess self, lldb::tid_t tid) -> bool"},
	 { "SBProcess_SetSelectedThreadByIndexID", _wrap_SBProcess_SetSelectedThreadByIndexID, METH_VARARGS, "SBProcess_SetSelectedThreadByIndexID(SBProcess self, uint32_t index_id) -> bool"},
	 { "SBProcess_GetNumQueues", _wrap_SBProcess_GetNumQueues, METH_O, "SBProcess_GetNumQueues(SBProcess self) -> uint32_t"},
	 { "SBProcess_GetQueueAtIndex", _wrap_SBProcess_GetQueueAtIndex, METH_VARARGS, "SBProcess_GetQueueAtIndex(SBProcess self, size_t index) -> SBQueue"},
	 { "SBProcess_GetState", _wrap_SBProcess_GetState, METH_O, "SBProcess_GetState(SBProcess self) -> lldb::StateType"},
	 { "SBProcess_GetExitStatus", _wrap_SBProcess_GetExitStatus, METH_O, "SBProcess_GetExitStatus(SBProcess self) -> int"},
	 { "SBProcess_GetExitDescription", _wrap_SBProcess_GetExitDescription, METH_O, "SBProcess_GetExitDescription(SBProcess self) -> char const *"},
	 { "SBProcess_GetProcessID", _wrap_SBProcess_GetProcessID, METH_O, "\n"
		"SBProcess_GetProcessID(SBProcess self) -> lldb::pid_t\n"
		"\n"
		"    Returns the process ID of the process.\n"
		""},
	 { "SBProcess_GetUniqueID", _wrap_SBProcess_GetUniqueID, METH_O, "\n"
		"SBProcess_GetUniqueID(SBProcess self) -> uint32_t\n"
		"\n"
		"    Returns an integer ID that is guaranteed to be unique across all process instances. This is not the process ID, just a unique integer for comparison and caching purposes.\n"
		""},
	 { "SBProcess_GetAddressByteSize", _wrap_SBProcess_GetAddressByteSize, METH_O, "SBProcess_GetAddressByteSize(SBProcess self) -> uint32_t"},
	 { "SBProcess_Destroy", _wrap_SBProcess_Destroy, METH_O, "\n"
		"SBProcess_Destroy(SBProcess self) -> SBError\n"
		"\n"
		"    Kills the process and shuts down all threads that were spawned to\n"
		"    track and monitor process.\n"
		""},
	 { "SBProcess_Continue", _wrap_SBProcess_Continue, METH_O, "SBProcess_Continue(SBProcess self) -> SBError"},
	 { "SBProcess_ContinueInDirection", _wrap_SBProcess_ContinueInDirection, METH_VARARGS, "SBProcess_ContinueInDirection(SBProcess self, lldb::RunDirection direction) -> SBError"},
	 { "SBProcess_Stop", _wrap_SBProcess_Stop, METH_O, "SBProcess_Stop(SBProcess self) -> SBError"},
	 { "SBProcess_Kill", _wrap_SBProcess_Kill, METH_O, "\n"
		"SBProcess_Kill(SBProcess self) -> SBError\n"
		"Same as Destroy(self).\n"
		""},
	 { "SBProcess_Detach", _wrap_SBProcess_Detach, METH_VARARGS, "\n"
		"SBProcess_Detach(SBProcess self) -> SBError\n"
		"SBProcess_Detach(SBProcess self, bool keep_stopped) -> SBError\n"
		""},
	 { "SBProcess_Signal", _wrap_SBProcess_Signal, METH_VARARGS, "\n"
		"SBProcess_Signal(SBProcess self, int signal) -> SBError\n"
		"Sends the process a unix signal.\n"
		""},
	 { "SBProcess_GetUnixSignals", _wrap_SBProcess_GetUnixSignals, METH_O, "SBProcess_GetUnixSignals(SBProcess self) -> SBUnixSignals"},
	 { "SBProcess_SendAsyncInterrupt", _wrap_SBProcess_SendAsyncInterrupt, METH_O, "SBProcess_SendAsyncInterrupt(SBProcess self)"},
	 { "SBProcess_GetStopID", _wrap_SBProcess_GetStopID, METH_VARARGS, "\n"
		"SBProcess_GetStopID(SBProcess self, bool include_expression_stops=False) -> uint32_t\n"
		"\n"
		"    Returns a stop id that will increase every time the process executes.  If\n"
		"    include_expression_stops is true, then stops caused by expression evaluation\n"
		"    will cause the returned value to increase, otherwise the counter returned will\n"
		"    only increase when execution is continued explicitly by the user.  Note, the value\n"
		"    will always increase, but may increase by more than one per stop.\n"
		""},
	 { "SBProcess_GetStopEventForStopID", _wrap_SBProcess_GetStopEventForStopID, METH_VARARGS, "\n"
		"Gets the stop event corresponding to stop ID.\n"
		"Note that it wasn't fully implemented and tracks only the stop\n"
		"event for the last natural stop ID.\n"
		"\n"
		":param [in]: stop_id\n"
		"      The ID of the stop event to return.\n"
		"\n"
		":rtype: :py:class:`SBEvent`\n"
		":return: \n"
		"      The stop event corresponding to stop ID.\n"
		""},
	 { "SBProcess_ForceScriptedState", _wrap_SBProcess_ForceScriptedState, METH_VARARGS, "\n"
		"If the process is a scripted process, changes its state to the new state.\n"
		"No-op otherwise.\n"
		"\n"
		":param [in]: new_state\n"
		"      The new state that the scripted process should be set to.\n"
		""},
	 { "SBProcess_ReadMemory", _wrap_SBProcess_ReadMemory, METH_VARARGS, "\n"
		"SBProcess_ReadMemory(SBProcess self, lldb::addr_t addr, void * buf, SBError error) -> size_t\n"
		"\n"
		"    Reads memory from the current process's address space and removes any\n"
		"    traps that may have been inserted into the memory. It returns the byte\n"
		"    buffer in a Python string. Example: ::\n"
		"\n"
		"        # Read 4 bytes from address 'addr' and assume error.Success() is True.\n"
		"        content = process.ReadMemory(addr, 4, error)\n"
		"        new_bytes = bytearray(content)\n"
		""},
	 { "SBProcess_WriteMemory", _wrap_SBProcess_WriteMemory, METH_VARARGS, "\n"
		"SBProcess_WriteMemory(SBProcess self, lldb::addr_t addr, void const * buf, SBError error) -> size_t\n"
		"\n"
		"    Writes memory to the current process's address space and maintains any\n"
		"    traps that might be present due to software breakpoints. Example: ::\n"
		"\n"
		"        # Create a Python string from the byte array.\n"
		"        new_value = str(bytes)\n"
		"        result = process.WriteMemory(addr, new_value, error)\n"
		"        if not error.Success() or result != len(bytes):\n"
		"            print('SBProcess.WriteMemory() failed!')\n"
		""},
	 { "SBProcess_ReadCStringFromMemory", _wrap_SBProcess_ReadCStringFromMemory, METH_VARARGS, "\n"
		"SBProcess_ReadCStringFromMemory(SBProcess self, lldb::addr_t addr, void * char_buf, SBError error) -> size_t\n"
		"\n"
		"    Reads a NUL terminated C string from the current process's address space.\n"
		"    It returns a python string of the exact length, or truncates the string if\n"
		"    the maximum character limit is reached. Example: ::\n"
		"\n"
		"        # Read a C string of at most 256 bytes from address '0x1000'\n"
		"        error = lldb.SBError()\n"
		"        cstring = process.ReadCStringFromMemory(0x1000, 256, error)\n"
		"        if error.Success():\n"
		"            print('cstring: ', cstring)\n"
		"        else\n"
		"            print('error: ', error)\n"
		""},
	 { "SBProcess_ReadUnsignedFromMemory", _wrap_SBProcess_ReadUnsignedFromMemory, METH_VARARGS, "\n"
		"SBProcess_ReadUnsignedFromMemory(SBProcess self, lldb::addr_t addr, uint32_t byte_size, SBError error) -> uint64_t\n"
		"\n"
		"    Reads an unsigned integer from memory given a byte size and an address.\n"
		"    Returns the unsigned integer that was read. Example: ::\n"
		"\n"
		"        # Read a 4 byte unsigned integer from address 0x1000\n"
		"        error = lldb.SBError()\n"
		"        uint = ReadUnsignedFromMemory(0x1000, 4, error)\n"
		"        if error.Success():\n"
		"            print('integer: %u' % uint)\n"
		"        else\n"
		"            print('error: ', error)\n"
		""},
	 { "SBProcess_ReadPointerFromMemory", _wrap_SBProcess_ReadPointerFromMemory, METH_VARARGS, "\n"
		"SBProcess_ReadPointerFromMemory(SBProcess self, lldb::addr_t addr, SBError error) -> lldb::addr_t\n"
		"\n"
		"    Reads a pointer from memory from an address and returns the value. Example: ::\n"
		"\n"
		"        # Read a pointer from address 0x1000\n"
		"        error = lldb.SBError()\n"
		"        ptr = ReadPointerFromMemory(0x1000, error)\n"
		"        if error.Success():\n"
		"            print('pointer: 0x%x' % ptr)\n"
		"        else\n"
		"            print('error: ', error)\n"
		""},
	 { "SBProcess_FindRangesInMemory", _wrap_SBProcess_FindRangesInMemory, METH_VARARGS, "SBProcess_FindRangesInMemory(SBProcess self, void const * buf, SBAddressRangeList ranges, uint32_t alignment, uint32_t max_matches, SBError error) -> SBAddressRangeList"},
	 { "SBProcess_FindInMemory", _wrap_SBProcess_FindInMemory, METH_VARARGS, "SBProcess_FindInMemory(SBProcess self, void const * buf, SBAddressRange range, uint32_t alignment, SBError error) -> lldb::addr_t"},
	 { "SBProcess_GetStateFromEvent", _wrap_SBProcess_GetStateFromEvent, METH_O, "SBProcess_GetStateFromEvent(SBEvent event) -> lldb::StateType"},
	 { "SBProcess_GetRestartedFromEvent", _wrap_SBProcess_GetRestartedFromEvent, METH_O, "SBProcess_GetRestartedFromEvent(SBEvent event) -> bool"},
	 { "SBProcess_GetNumRestartedReasonsFromEvent", _wrap_SBProcess_GetNumRestartedReasonsFromEvent, METH_O, "SBProcess_GetNumRestartedReasonsFromEvent(SBEvent event) -> size_t"},
	 { "SBProcess_GetRestartedReasonAtIndexFromEvent", _wrap_SBProcess_GetRestartedReasonAtIndexFromEvent, METH_VARARGS, "SBProcess_GetRestartedReasonAtIndexFromEvent(SBEvent event, size_t idx) -> char const *"},
	 { "SBProcess_GetProcessFromEvent", _wrap_SBProcess_GetProcessFromEvent, METH_O, "SBProcess_GetProcessFromEvent(SBEvent event) -> SBProcess"},
	 { "SBProcess_GetInterruptedFromEvent", _wrap_SBProcess_GetInterruptedFromEvent, METH_O, "SBProcess_GetInterruptedFromEvent(SBEvent event) -> bool"},
	 { "SBProcess_GetStructuredDataFromEvent", _wrap_SBProcess_GetStructuredDataFromEvent, METH_O, "SBProcess_GetStructuredDataFromEvent(SBEvent event) -> SBStructuredData"},
	 { "SBProcess_EventIsProcessEvent", _wrap_SBProcess_EventIsProcessEvent, METH_O, "SBProcess_EventIsProcessEvent(SBEvent event) -> bool"},
	 { "SBProcess_EventIsStructuredDataEvent", _wrap_SBProcess_EventIsStructuredDataEvent, METH_O, "SBProcess_EventIsStructuredDataEvent(SBEvent event) -> bool"},
	 { "SBProcess_GetBroadcaster", _wrap_SBProcess_GetBroadcaster, METH_O, "SBProcess_GetBroadcaster(SBProcess self) -> SBBroadcaster"},
	 { "SBProcess_GetBroadcasterClass", _wrap_SBProcess_GetBroadcasterClass, METH_NOARGS, "\n"
		"SBProcess_GetBroadcasterClass() -> char const *\n"
		"Get default process broadcaster class name (lldb.process).\n"
		""},
	 { "SBProcess_GetDescription", _wrap_SBProcess_GetDescription, METH_VARARGS, "SBProcess_GetDescription(SBProcess self, SBStream description) -> bool"},
	 { "SBProcess_GetExtendedCrashInformation", _wrap_SBProcess_GetExtendedCrashInformation, METH_O, "\n"
		"SBProcess_GetExtendedCrashInformation(SBProcess self) -> SBStructuredData\n"
		"\n"
		"    Returns the process' extended crash information.\n"
		""},
	 { "SBProcess_GetNumSupportedHardwareWatchpoints", _wrap_SBProcess_GetNumSupportedHardwareWatchpoints, METH_VARARGS, "SBProcess_GetNumSupportedHardwareWatchpoints(SBProcess self, SBError error) -> uint32_t"},
	 { "SBProcess_LoadImage", _wrap_SBProcess_LoadImage, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		"Load a shared library into this process.\n"
		"\n"
		":type remote_image_spec: :py:class:`SBFileSpec`, in\n"
		":param remote_image_spec:\n"
		"        The path for the shared library on the target what you want\n"
		"        to load.\n"
		"\n"
		":type error: :py:class:`SBError`, out\n"
		":param error:\n"
		"        An error object that gets filled in with any errors that\n"
		"        might occur when trying to load the shared library.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"        A token that represents the shared library that can be\n"
		"        later used to unload the shared library. A value of\n"
		"        LLDB_INVALID_IMAGE_TOKEN will be returned if the shared\n"
		"        library can't be opened.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		"Load a shared library into this process.\n"
		"\n"
		":type local_image_spec: :py:class:`SBFileSpec`, in\n"
		":param local_image_spec:\n"
		"        The file spec that points to the shared library that you\n"
		"        want to load if the library is located on the host. The\n"
		"        library will be copied over to the location specified by\n"
		"        remote_image_spec or into the current working directory with\n"
		"        the same filename if the remote_image_spec isn't specified.\n"
		"\n"
		":type remote_image_spec: :py:class:`SBFileSpec`, in\n"
		":param remote_image_spec:\n"
		"        If local_image_spec is specified then the location where the\n"
		"        library should be copied over from the host. If\n"
		"        local_image_spec isn't specified, then the path for the\n"
		"        shared library on the target what you want to load.\n"
		"\n"
		":type error: :py:class:`SBError`, out\n"
		":param error:\n"
		"        An error object that gets filled in with any errors that\n"
		"        might occur when trying to load the shared library.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"        A token that represents the shared library that can be\n"
		"        later used to unload the shared library. A value of\n"
		"        LLDB_INVALID_IMAGE_TOKEN will be returned if the shared\n"
		"        library can't be opened.\n"
		""},
	 { "SBProcess_LoadImageUsingPaths", _wrap_SBProcess_LoadImageUsingPaths, METH_VARARGS, "\n"
		"SBProcess_LoadImageUsingPaths(SBProcess self, SBFileSpec image_spec, SBStringList paths, SBFileSpec loaded_path, SBError error) -> uint32_t\n"
		"\n"
		"    Load the library whose filename is given by image_spec looking in all the\n"
		"    paths supplied in the paths argument.  If successful, return a token that\n"
		"    can be passed to UnloadImage and fill loaded_path with the path that was\n"
		"    successfully loaded.  On failure, return\n"
		"    lldb.LLDB_INVALID_IMAGE_TOKEN.\n"
		""},
	 { "SBProcess_UnloadImage", _wrap_SBProcess_UnloadImage, METH_VARARGS, "SBProcess_UnloadImage(SBProcess self, uint32_t image_token) -> SBError"},
	 { "SBProcess_SendEventData", _wrap_SBProcess_SendEventData, METH_VARARGS, "SBProcess_SendEventData(SBProcess self, char const * data) -> SBError"},
	 { "SBProcess_GetNumExtendedBacktraceTypes", _wrap_SBProcess_GetNumExtendedBacktraceTypes, METH_O, "\n"
		"SBProcess_GetNumExtendedBacktraceTypes(SBProcess self) -> uint32_t\n"
		"\n"
		"    Return the number of different thread-origin extended backtraces\n"
		"    this process can support as a uint32_t.\n"
		"    When the process is stopped and you have an SBThread, lldb may be\n"
		"    able to show a backtrace of when that thread was originally created,\n"
		"    or the work item was enqueued to it (in the case of a libdispatch\n"
		"    queue).\n"
		""},
	 { "SBProcess_GetExtendedBacktraceTypeAtIndex", _wrap_SBProcess_GetExtendedBacktraceTypeAtIndex, METH_VARARGS, "\n"
		"SBProcess_GetExtendedBacktraceTypeAtIndex(SBProcess self, uint32_t idx) -> char const *\n"
		"\n"
		"    Takes an index argument, returns the name of one of the thread-origin\n"
		"    extended backtrace methods as a str.\n"
		""},
	 { "SBProcess_GetHistoryThreads", _wrap_SBProcess_GetHistoryThreads, METH_VARARGS, "SBProcess_GetHistoryThreads(SBProcess self, lldb::addr_t addr) -> SBThreadCollection"},
	 { "SBProcess_IsInstrumentationRuntimePresent", _wrap_SBProcess_IsInstrumentationRuntimePresent, METH_VARARGS, "SBProcess_IsInstrumentationRuntimePresent(SBProcess self, lldb::InstrumentationRuntimeType type) -> bool"},
	 { "SBProcess_SaveCore", _wrap_SBProcess_SaveCore, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		"Save the state of the process in a core file.\n"
		"\n"
		":type file_name: string, in\n"
		":param file_name: - The name of the file to save the core file to.\n"
		"\n"
		":type flavor: string, in\n"
		":param flavor: - Specify the flavor of a core file plug-in to save.\n"
		"    Currently supported flavors include \"mach-o\" and \"minidump\"\n"
		"\n"
		":type core_style: int, in\n"
		":param core_style: - Specify the style of a core file to save.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		"Save the state of the process with the a flavor that matches the\n"
		"current process' main executable (if supported).\n"
		"\n"
		":type file_name: string, in\n"
		":param file_name: - The name of the file to save the core file to.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 3:*\n"
		"Save the state of the process with the desired settings\n"
		"as defined in the options object.\n"
		"\n"
		":type options: :py:class:`SBSaveCoreOptions`, in\n"
		":param options: - The options to use when saving the core file.\n"
		""},
	 { "SBProcess_GetMemoryRegionInfo", _wrap_SBProcess_GetMemoryRegionInfo, METH_VARARGS, "\n"
		"Query the address load_addr and store the details of the memory\n"
		"region that contains it in the supplied SBMemoryRegionInfo object.\n"
		"To iterate over all memory regions use GetMemoryRegionList.\n"
		"\n"
		":type load_addr: int, in\n"
		":param load_addr:\n"
		"        The address to be queried.\n"
		"\n"
		":type region_info: :py:class:`SBMemoryRegionInfo`, out\n"
		":param region_info:\n"
		"        A reference to an SBMemoryRegionInfo object that will contain\n"
		"        the details of the memory region containing load_addr.\n"
		"\n"
		":rtype: :py:class:`SBError`\n"
		":return: \n"
		"        An error object describes any errors that occurred while\n"
		"        querying load_addr.\n"
		""},
	 { "SBProcess_GetMemoryRegions", _wrap_SBProcess_GetMemoryRegions, METH_O, "\n"
		"SBProcess_GetMemoryRegions(SBProcess self) -> SBMemoryRegionInfoList\n"
		"\n"
		"    Get a list of all the memory regions associated with this process. ::\n"
		"\n"
		"        readable_regions = []\n"
		"        for region in process.GetMemoryRegions():\n"
		"            if region.IsReadable():\n"
		"                readable_regions.append(region)\n"
		"\n"
		"\n"
		""},
	 { "SBProcess_GetProcessInfo", _wrap_SBProcess_GetProcessInfo, METH_O, "\n"
		"SBProcess_GetProcessInfo(SBProcess self) -> SBProcessInfo\n"
		"\n"
		"    Get information about the process.\n"
		"    Valid process info will only be returned when the process is alive,\n"
		"    use IsValid() to check if the info returned is valid. ::\n"
		"\n"
		"        process_info = process.GetProcessInfo()\n"
		"        if process_info.IsValid():\n"
		"            process_info.GetProcessID()\n"
		""},
	 { "SBProcess_GetCoreFile", _wrap_SBProcess_GetCoreFile, METH_O, "\n"
		"Get the file specification for the core file that is currently being used\n"
		"for the process. If the process is not loaded from a core file, then an\n"
		"invalid file specification will be returned.\n"
		"\n"
		":rtype: :py:class:`SBFileSpec`\n"
		":return: \n"
		"        The path to the core file for this target or an invalid file spec if\n"
		"        the process isn't loaded from a core file.\n"
		""},
	 { "SBProcess_GetAddressMask", _wrap_SBProcess_GetAddressMask, METH_VARARGS, "\n"
		"SBProcess_GetAddressMask(SBProcess self, lldb::AddressMaskType type, lldb::AddressMaskRange addr_range=eAddressMaskRangeLow) -> lldb::addr_t\n"
		"\n"
		"    Get the current address mask in this Process of a given type.\n"
		"    There are lldb.eAddressMaskTypeCode and lldb.eAddressMaskTypeData address\n"
		"    masks, and on most Targets, the the Data address mask is more general\n"
		"    because there are no alignment restrictions, as there can be with Code\n"
		"    addresses.\n"
		"    lldb.eAddressMaskTypeAny may be used to get the most general mask.\n"
		"    The bits which are not used for addressing are set to 1 in the returned\n"
		"    mask.\n"
		"    In an unusual environment with different address masks for high and low\n"
		"    memory, this may also be specified.  This is uncommon, default is\n"
		"    lldb.eAddressMaskRangeLow.\n"
		""},
	 { "SBProcess_SetAddressMask", _wrap_SBProcess_SetAddressMask, METH_VARARGS, "\n"
		"SBProcess_SetAddressMask(SBProcess self, lldb::AddressMaskType type, lldb::addr_t mask, lldb::AddressMaskRange addr_range=eAddressMaskRangeLow)\n"
		"\n"
		"    Set the current address mask in this Process for a given type,\n"
		"    lldb.eAddressMaskTypeCode or lldb.eAddressMaskTypeData.  Bits that are not\n"
		"    used for addressing should be set to 1 in the mask.\n"
		"    When setting all masks, lldb.eAddressMaskTypeAll may be specified.\n"
		"    In an unusual environment with different address masks for high and low\n"
		"    memory, this may also be specified.  This is uncommon, default is\n"
		"    lldb.eAddressMaskRangeLow.\n"
		""},
	 { "SBProcess_SetAddressableBits", _wrap_SBProcess_SetAddressableBits, METH_VARARGS, "\n"
		"SBProcess_SetAddressableBits(SBProcess self, lldb::AddressMaskType type, uint32_t num_bits, lldb::AddressMaskRange addr_range=eAddressMaskRangeLow)\n"
		"\n"
		"    Set the number of low bits relevant for addressing in this Process \n"
		"    for a given type, lldb.eAddressMaskTypeCode or lldb.eAddressMaskTypeData.\n"
		"    When setting all masks, lldb.eAddressMaskTypeAll may be specified.\n"
		"    In an unusual environment with different address masks for high and low\n"
		"    memory, the address range  may also be specified.  This is uncommon, \n"
		"    default is lldb.eAddressMaskRangeLow.\n"
		""},
	 { "SBProcess_FixAddress", _wrap_SBProcess_FixAddress, METH_VARARGS, "\n"
		"SBProcess_FixAddress(SBProcess self, lldb::addr_t addr, lldb::AddressMaskType type=eAddressMaskTypeAny) -> lldb::addr_t\n"
		"\n"
		"    Given a virtual address, clear the bits that are not used for addressing\n"
		"    (and may be used for metadata, memory tagging, point authentication, etc).\n"
		"    By default the most general mask, lldb.eAddressMaskTypeAny is used to \n"
		"    process the address, but lldb.eAddressMaskTypeData and \n"
		"    lldb.eAddressMaskTypeCode may be specified if the type of address is known.\n"
		""},
	 { "SBProcess_AllocateMemory", _wrap_SBProcess_AllocateMemory, METH_VARARGS, "\n"
		"SBProcess_AllocateMemory(SBProcess self, size_t size, uint32_t permissions, SBError error) -> lldb::addr_t\n"
		"\n"
		"    Allocates a block of memory within the process, with size and\n"
		"    access permissions specified in the arguments. The permissions\n"
		"    argument is an or-combination of zero or more of\n"
		"    lldb.ePermissionsWritable, lldb.ePermissionsReadable, and\n"
		"    lldb.ePermissionsExecutable. Returns the address\n"
		"    of the allocated buffer in the process, or\n"
		"    lldb.LLDB_INVALID_ADDRESS if the allocation failed.\n"
		""},
	 { "SBProcess_DeallocateMemory", _wrap_SBProcess_DeallocateMemory, METH_VARARGS, "\n"
		"SBProcess_DeallocateMemory(SBProcess self, lldb::addr_t ptr) -> SBError\n"
		"\n"
		"    Deallocates the block of memory (previously allocated using\n"
		"    AllocateMemory) given in the argument.\n"
		""},
	 { "SBProcess_GetScriptedImplementation", _wrap_SBProcess_GetScriptedImplementation, METH_O, "\n"
		"SBProcess_GetScriptedImplementation(SBProcess self) -> SBScriptObject\n"
		"\n"
		"    Returns the implementation object of the process plugin if available. None\n"
		"    otherwise.\n"
		""},
	 { "SBProcess_GetStatus", _wrap_SBProcess_GetStatus, METH_VARARGS, "SBProcess_GetStatus(SBProcess self, SBStream status)"},
	 { "SBProcess___repr__", _wrap_SBProcess___repr__, METH_O, "SBProcess___repr__(SBProcess self) -> std::string"},
	 { "SBProcess_swigregister", SBProcess_swigregister, METH_O, NULL},
	 { "SBProcess_swiginit", SBProcess_swiginit, METH_VARARGS, NULL},
	 { "new_SBProcessInfo", _wrap_new_SBProcessInfo, METH_VARARGS, "\n"
		"SBProcessInfo()\n"
		"new_SBProcessInfo(SBProcessInfo rhs) -> SBProcessInfo\n"
		""},
	 { "delete_SBProcessInfo", _wrap_delete_SBProcessInfo, METH_O, "delete_SBProcessInfo(SBProcessInfo self)"},
	 { "SBProcessInfo___nonzero__", _wrap_SBProcessInfo___nonzero__, METH_O, "SBProcessInfo___nonzero__(SBProcessInfo self) -> bool"},
	 { "SBProcessInfo_IsValid", _wrap_SBProcessInfo_IsValid, METH_O, "SBProcessInfo_IsValid(SBProcessInfo self) -> bool"},
	 { "SBProcessInfo_GetName", _wrap_SBProcessInfo_GetName, METH_O, "SBProcessInfo_GetName(SBProcessInfo self) -> char const *"},
	 { "SBProcessInfo_GetExecutableFile", _wrap_SBProcessInfo_GetExecutableFile, METH_O, "SBProcessInfo_GetExecutableFile(SBProcessInfo self) -> SBFileSpec"},
	 { "SBProcessInfo_GetProcessID", _wrap_SBProcessInfo_GetProcessID, METH_O, "SBProcessInfo_GetProcessID(SBProcessInfo self) -> lldb::pid_t"},
	 { "SBProcessInfo_GetUserID", _wrap_SBProcessInfo_GetUserID, METH_O, "SBProcessInfo_GetUserID(SBProcessInfo self) -> uint32_t"},
	 { "SBProcessInfo_GetGroupID", _wrap_SBProcessInfo_GetGroupID, METH_O, "SBProcessInfo_GetGroupID(SBProcessInfo self) -> uint32_t"},
	 { "SBProcessInfo_UserIDIsValid", _wrap_SBProcessInfo_UserIDIsValid, METH_O, "SBProcessInfo_UserIDIsValid(SBProcessInfo self) -> bool"},
	 { "SBProcessInfo_GroupIDIsValid", _wrap_SBProcessInfo_GroupIDIsValid, METH_O, "SBProcessInfo_GroupIDIsValid(SBProcessInfo self) -> bool"},
	 { "SBProcessInfo_GetEffectiveUserID", _wrap_SBProcessInfo_GetEffectiveUserID, METH_O, "SBProcessInfo_GetEffectiveUserID(SBProcessInfo self) -> uint32_t"},
	 { "SBProcessInfo_GetEffectiveGroupID", _wrap_SBProcessInfo_GetEffectiveGroupID, METH_O, "SBProcessInfo_GetEffectiveGroupID(SBProcessInfo self) -> uint32_t"},
	 { "SBProcessInfo_EffectiveUserIDIsValid", _wrap_SBProcessInfo_EffectiveUserIDIsValid, METH_O, "SBProcessInfo_EffectiveUserIDIsValid(SBProcessInfo self) -> bool"},
	 { "SBProcessInfo_EffectiveGroupIDIsValid", _wrap_SBProcessInfo_EffectiveGroupIDIsValid, METH_O, "SBProcessInfo_EffectiveGroupIDIsValid(SBProcessInfo self) -> bool"},
	 { "SBProcessInfo_GetParentProcessID", _wrap_SBProcessInfo_GetParentProcessID, METH_O, "SBProcessInfo_GetParentProcessID(SBProcessInfo self) -> lldb::pid_t"},
	 { "SBProcessInfo_GetTriple", _wrap_SBProcessInfo_GetTriple, METH_O, "\n"
		"SBProcessInfo_GetTriple(SBProcessInfo self) -> char const *\n"
		"Return the target triple (arch-vendor-os) for the described process.\n"
		""},
	 { "SBProcessInfo_swigregister", SBProcessInfo_swigregister, METH_O, NULL},
	 { "SBProcessInfo_swiginit", SBProcessInfo_swiginit, METH_VARARGS, NULL},
	 { "delete_SBProcessInfoList", _wrap_delete_SBProcessInfoList, METH_O, "delete_SBProcessInfoList(SBProcessInfoList self)"},
	 { "new_SBProcessInfoList", _wrap_new_SBProcessInfoList, METH_VARARGS, "\n"
		"SBProcessInfoList()\n"
		"new_SBProcessInfoList(SBProcessInfoList rhs) -> SBProcessInfoList\n"
		""},
	 { "SBProcessInfoList_GetSize", _wrap_SBProcessInfoList_GetSize, METH_O, "SBProcessInfoList_GetSize(SBProcessInfoList self) -> uint32_t"},
	 { "SBProcessInfoList_GetProcessInfoAtIndex", _wrap_SBProcessInfoList_GetProcessInfoAtIndex, METH_VARARGS, "SBProcessInfoList_GetProcessInfoAtIndex(SBProcessInfoList self, uint32_t idx, SBProcessInfo info) -> bool"},
	 { "SBProcessInfoList_Clear", _wrap_SBProcessInfoList_Clear, METH_O, "SBProcessInfoList_Clear(SBProcessInfoList self)"},
	 { "SBProcessInfoList_swigregister", SBProcessInfoList_swigregister, METH_O, NULL},
	 { "SBProcessInfoList_swiginit", SBProcessInfoList_swiginit, METH_VARARGS, NULL},
	 { "new_SBProgress", _wrap_new_SBProgress, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		"Construct a progress object with a title, details and a given debugger.\n"
		":type title: string\n"
		":param title:\n"
		"      The title of the progress object.\n"
		":type details: string\n"
		":param details:\n"
		"      The details of the progress object.\n"
		":type debugger: :py:class:`SBDebugger`\n"
		":param debugger:\n"
		"      The debugger for this progress object to report to.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		"Construct a progress object with a title, details, the total units of work\n"
		"to be done, and a given debugger.\n"
		":type title: string\n"
		":param title:\n"
		"      The title of the progress object.\n"
		":type details: string\n"
		":param details:\n"
		"      The details of the progress object.\n"
		":type total_units: int\n"
		":param total_units:\n"
		"      The total number of units of work to be done.\n"
		":type debugger: :py:class:`SBDebugger`\n"
		":param debugger:\n"
		"      The debugger for this progress object to report to.\n"
		""},
	 { "delete_SBProgress", _wrap_delete_SBProgress, METH_O, "delete_SBProgress(SBProgress self)"},
	 { "SBProgress_Increment", _wrap_SBProgress_Increment, METH_VARARGS, "SBProgress_Increment(SBProgress self, uint64_t amount, char const * description=None)"},
	 { "SBProgress_Finalize", _wrap_SBProgress_Finalize, METH_O, "\n"
		"SBProgress_Finalize(SBProgress self)\n"
		"Finalize the SBProgress, which will cause a progress end event to be emitted. This \n"
		"happens automatically when the SBProcess object is destroyed, but can be done explicitly \n"
		"with Finalize to avoid having to rely on the language semantics for destruction.\n"
		"\n"
		"Note once finalized, no further increments will be processed.\n"
		""},
	 { "SBProgress_swigregister", SBProgress_swigregister, METH_O, NULL},
	 { "SBProgress_swiginit", SBProgress_swiginit, METH_VARARGS, NULL},
	 { "new_SBQueue", _wrap_new_SBQueue, METH_VARARGS, "\n"
		"SBQueue()\n"
		"new_SBQueue(SBQueue rhs) -> SBQueue\n"
		""},
	 { "delete_SBQueue", _wrap_delete_SBQueue, METH_O, "delete_SBQueue(SBQueue self)"},
	 { "SBQueue___nonzero__", _wrap_SBQueue___nonzero__, METH_O, "SBQueue___nonzero__(SBQueue self) -> bool"},
	 { "SBQueue_IsValid", _wrap_SBQueue_IsValid, METH_O, "SBQueue_IsValid(SBQueue self) -> bool"},
	 { "SBQueue_Clear", _wrap_SBQueue_Clear, METH_O, "SBQueue_Clear(SBQueue self)"},
	 { "SBQueue_GetProcess", _wrap_SBQueue_GetProcess, METH_O, "SBQueue_GetProcess(SBQueue self) -> SBProcess"},
	 { "SBQueue_GetQueueID", _wrap_SBQueue_GetQueueID, METH_O, "\n"
		"SBQueue_GetQueueID(SBQueue self) -> lldb::queue_id_t\n"
		"\n"
		"    Returns an lldb::queue_id_t type unique identifier number for this\n"
		"    queue that will not be used by any other queue during this process'\n"
		"    execution.  These ID numbers often start at 1 with the first\n"
		"    system-created queues and increment from there.\n"
		""},
	 { "SBQueue_GetName", _wrap_SBQueue_GetName, METH_O, "SBQueue_GetName(SBQueue self) -> char const *"},
	 { "SBQueue_GetIndexID", _wrap_SBQueue_GetIndexID, METH_O, "SBQueue_GetIndexID(SBQueue self) -> uint32_t"},
	 { "SBQueue_GetNumThreads", _wrap_SBQueue_GetNumThreads, METH_O, "SBQueue_GetNumThreads(SBQueue self) -> uint32_t"},
	 { "SBQueue_GetThreadAtIndex", _wrap_SBQueue_GetThreadAtIndex, METH_VARARGS, "SBQueue_GetThreadAtIndex(SBQueue self, uint32_t arg2) -> SBThread"},
	 { "SBQueue_GetNumPendingItems", _wrap_SBQueue_GetNumPendingItems, METH_O, "SBQueue_GetNumPendingItems(SBQueue self) -> uint32_t"},
	 { "SBQueue_GetPendingItemAtIndex", _wrap_SBQueue_GetPendingItemAtIndex, METH_VARARGS, "SBQueue_GetPendingItemAtIndex(SBQueue self, uint32_t arg2) -> SBQueueItem"},
	 { "SBQueue_GetNumRunningItems", _wrap_SBQueue_GetNumRunningItems, METH_O, "SBQueue_GetNumRunningItems(SBQueue self) -> uint32_t"},
	 { "SBQueue_GetKind", _wrap_SBQueue_GetKind, METH_O, "\n"
		"SBQueue_GetKind(SBQueue self) -> lldb::QueueKind\n"
		"\n"
		"    Returns an lldb::QueueKind enumerated value (e.g. eQueueKindUnknown,\n"
		"    eQueueKindSerial, eQueueKindConcurrent) describing the type of this\n"
		"    queue.\n"
		""},
	 { "SBQueue_swigregister", SBQueue_swigregister, METH_O, NULL},
	 { "SBQueue_swiginit", SBQueue_swiginit, METH_VARARGS, NULL},
	 { "new_SBQueueItem", _wrap_new_SBQueueItem, METH_NOARGS, "new_SBQueueItem() -> SBQueueItem"},
	 { "delete_SBQueueItem", _wrap_delete_SBQueueItem, METH_O, "delete_SBQueueItem(SBQueueItem self)"},
	 { "SBQueueItem___nonzero__", _wrap_SBQueueItem___nonzero__, METH_O, "SBQueueItem___nonzero__(SBQueueItem self) -> bool"},
	 { "SBQueueItem_IsValid", _wrap_SBQueueItem_IsValid, METH_O, "SBQueueItem_IsValid(SBQueueItem self) -> bool"},
	 { "SBQueueItem_Clear", _wrap_SBQueueItem_Clear, METH_O, "SBQueueItem_Clear(SBQueueItem self)"},
	 { "SBQueueItem_GetKind", _wrap_SBQueueItem_GetKind, METH_O, "SBQueueItem_GetKind(SBQueueItem self) -> lldb::QueueItemKind"},
	 { "SBQueueItem_SetKind", _wrap_SBQueueItem_SetKind, METH_VARARGS, "SBQueueItem_SetKind(SBQueueItem self, lldb::QueueItemKind kind)"},
	 { "SBQueueItem_GetAddress", _wrap_SBQueueItem_GetAddress, METH_O, "SBQueueItem_GetAddress(SBQueueItem self) -> SBAddress"},
	 { "SBQueueItem_SetAddress", _wrap_SBQueueItem_SetAddress, METH_VARARGS, "SBQueueItem_SetAddress(SBQueueItem self, SBAddress addr)"},
	 { "SBQueueItem_GetExtendedBacktraceThread", _wrap_SBQueueItem_GetExtendedBacktraceThread, METH_VARARGS, "SBQueueItem_GetExtendedBacktraceThread(SBQueueItem self, char const * type) -> SBThread"},
	 { "SBQueueItem_swigregister", SBQueueItem_swigregister, METH_O, NULL},
	 { "SBQueueItem_swiginit", SBQueueItem_swiginit, METH_VARARGS, NULL},
	 { "SBReproducer_Capture", _wrap_SBReproducer_Capture, METH_O, "SBReproducer_Capture(char const * path) -> char const *"},
	 { "SBReproducer_PassiveReplay", _wrap_SBReproducer_PassiveReplay, METH_O, "SBReproducer_PassiveReplay(char const * path) -> char const *"},
	 { "SBReproducer_SetAutoGenerate", _wrap_SBReproducer_SetAutoGenerate, METH_O, "SBReproducer_SetAutoGenerate(bool b) -> bool"},
	 { "SBReproducer_SetWorkingDirectory", _wrap_SBReproducer_SetWorkingDirectory, METH_O, "\n"
		"The working directory is set to the current working directory when the\n"
		"reproducers are initialized. This method allows setting a different\n"
		"working directory. This is used by the API test suite  which temporarily\n"
		"changes the directory to where the test lives. This is a NO-OP in every\n"
		"mode but capture.\n"
		""},
	 { "new_SBReproducer", _wrap_new_SBReproducer, METH_NOARGS, "new_SBReproducer() -> SBReproducer"},
	 { "delete_SBReproducer", _wrap_delete_SBReproducer, METH_O, "delete_SBReproducer(SBReproducer self)"},
	 { "SBReproducer_swigregister", SBReproducer_swigregister, METH_O, NULL},
	 { "SBReproducer_swiginit", SBReproducer_swiginit, METH_VARARGS, NULL},
	 { "new_SBScriptObject", _wrap_new_SBScriptObject, METH_VARARGS, "\n"
		"SBScriptObject(lldb::ScriptObjectPtr const ptr, lldb::ScriptLanguage lang)\n"
		"new_SBScriptObject(SBScriptObject rhs) -> SBScriptObject\n"
		""},
	 { "delete_SBScriptObject", _wrap_delete_SBScriptObject, METH_O, "delete_SBScriptObject(SBScriptObject self)"},
	 { "SBScriptObject___nonzero__", _wrap_SBScriptObject___nonzero__, METH_O, "SBScriptObject___nonzero__(SBScriptObject self) -> bool"},
	 { "SBScriptObject___ne__", _wrap_SBScriptObject___ne__, METH_VARARGS, "SBScriptObject___ne__(SBScriptObject self, SBScriptObject rhs) -> bool"},
	 { "SBScriptObject_IsValid", _wrap_SBScriptObject_IsValid, METH_O, "SBScriptObject_IsValid(SBScriptObject self) -> bool"},
	 { "SBScriptObject_GetPointer", _wrap_SBScriptObject_GetPointer, METH_O, "SBScriptObject_GetPointer(SBScriptObject self) -> lldb::ScriptObjectPtr"},
	 { "SBScriptObject_GetLanguage", _wrap_SBScriptObject_GetLanguage, METH_O, "SBScriptObject_GetLanguage(SBScriptObject self) -> lldb::ScriptLanguage"},
	 { "SBScriptObject_swigregister", SBScriptObject_swigregister, METH_O, NULL},
	 { "SBScriptObject_swiginit", SBScriptObject_swiginit, METH_VARARGS, NULL},
	 { "new_SBSection", _wrap_new_SBSection, METH_VARARGS, "\n"
		"SBSection()\n"
		"new_SBSection(SBSection rhs) -> SBSection\n"
		""},
	 { "delete_SBSection", _wrap_delete_SBSection, METH_O, "delete_SBSection(SBSection self)"},
	 { "SBSection___nonzero__", _wrap_SBSection___nonzero__, METH_O, "SBSection___nonzero__(SBSection self) -> bool"},
	 { "SBSection_IsValid", _wrap_SBSection_IsValid, METH_O, "SBSection_IsValid(SBSection self) -> bool"},
	 { "SBSection_GetName", _wrap_SBSection_GetName, METH_O, "SBSection_GetName(SBSection self) -> char const *"},
	 { "SBSection_GetParent", _wrap_SBSection_GetParent, METH_O, "SBSection_GetParent(SBSection self) -> SBSection"},
	 { "SBSection_FindSubSection", _wrap_SBSection_FindSubSection, METH_VARARGS, "SBSection_FindSubSection(SBSection self, char const * sect_name) -> SBSection"},
	 { "SBSection_GetNumSubSections", _wrap_SBSection_GetNumSubSections, METH_O, "SBSection_GetNumSubSections(SBSection self) -> size_t"},
	 { "SBSection_GetSubSectionAtIndex", _wrap_SBSection_GetSubSectionAtIndex, METH_VARARGS, "SBSection_GetSubSectionAtIndex(SBSection self, size_t idx) -> SBSection"},
	 { "SBSection_GetFileAddress", _wrap_SBSection_GetFileAddress, METH_O, "SBSection_GetFileAddress(SBSection self) -> lldb::addr_t"},
	 { "SBSection_GetLoadAddress", _wrap_SBSection_GetLoadAddress, METH_VARARGS, "SBSection_GetLoadAddress(SBSection self, SBTarget target) -> lldb::addr_t"},
	 { "SBSection_GetByteSize", _wrap_SBSection_GetByteSize, METH_O, "SBSection_GetByteSize(SBSection self) -> lldb::addr_t"},
	 { "SBSection_GetFileOffset", _wrap_SBSection_GetFileOffset, METH_O, "SBSection_GetFileOffset(SBSection self) -> uint64_t"},
	 { "SBSection_GetFileByteSize", _wrap_SBSection_GetFileByteSize, METH_O, "SBSection_GetFileByteSize(SBSection self) -> uint64_t"},
	 { "SBSection_GetSectionData", _wrap_SBSection_GetSectionData, METH_VARARGS, "\n"
		"SBSection_GetSectionData(SBSection self) -> SBData\n"
		"SBSection_GetSectionData(SBSection self, uint64_t offset, uint64_t size) -> SBData\n"
		""},
	 { "SBSection_GetSectionType", _wrap_SBSection_GetSectionType, METH_O, "SBSection_GetSectionType(SBSection self) -> lldb::SectionType"},
	 { "SBSection_GetPermissions", _wrap_SBSection_GetPermissions, METH_O, "\n"
		"Gets the permissions (RWX) of the section of the object file\n"
		"\n"
		"Returns a mask of bits of enum lldb::Permissions for this section.\n"
		"Sections for which permissions are not defined, 0 is returned for\n"
		"them. The binary representation of this value corresponds to [XRW]\n"
		"i.e. for a section having read and execute permissions, the value\n"
		"returned is 6\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"        Returns an unsigned value for Permissions for the section.\n"
		""},
	 { "SBSection_GetTargetByteSize", _wrap_SBSection_GetTargetByteSize, METH_O, "\n"
		"SBSection_GetTargetByteSize(SBSection self) -> uint32_t\n"
		"\n"
		"    Return the size of a target's byte represented by this section\n"
		"    in numbers of host bytes. Note that certain architectures have\n"
		"    varying minimum addressable unit (i.e. byte) size for their\n"
		"    CODE or DATA buses.\n"
		"\n"
		"    @return\n"
		"        The number of host (8-bit) bytes needed to hold a target byte\n"
		""},
	 { "SBSection_GetAlignment", _wrap_SBSection_GetAlignment, METH_O, "\n"
		"Return the alignment of the section in bytes\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"        The alignment of the section in bytes\n"
		""},
	 { "SBSection___eq__", _wrap_SBSection___eq__, METH_VARARGS, "SBSection___eq__(SBSection self, SBSection rhs) -> bool"},
	 { "SBSection___ne__", _wrap_SBSection___ne__, METH_VARARGS, "SBSection___ne__(SBSection self, SBSection rhs) -> bool"},
	 { "SBSection_GetDescription", _wrap_SBSection_GetDescription, METH_VARARGS, "SBSection_GetDescription(SBSection self, SBStream description) -> bool"},
	 { "SBSection___repr__", _wrap_SBSection___repr__, METH_O, "SBSection___repr__(SBSection self) -> std::string"},
	 { "SBSection_swigregister", SBSection_swigregister, METH_O, NULL},
	 { "SBSection_swiginit", SBSection_swiginit, METH_VARARGS, NULL},
	 { "new_SBSourceManager", _wrap_new_SBSourceManager, METH_VARARGS, "\n"
		"SBSourceManager(SBDebugger debugger)\n"
		"SBSourceManager(SBTarget target)\n"
		"new_SBSourceManager(SBSourceManager rhs) -> SBSourceManager\n"
		""},
	 { "delete_SBSourceManager", _wrap_delete_SBSourceManager, METH_O, "delete_SBSourceManager(SBSourceManager self)"},
	 { "SBSourceManager_DisplaySourceLinesWithLineNumbers", _wrap_SBSourceManager_DisplaySourceLinesWithLineNumbers, METH_VARARGS, "SBSourceManager_DisplaySourceLinesWithLineNumbers(SBSourceManager self, SBFileSpec file, uint32_t line, uint32_t context_before, uint32_t context_after, char const * current_line_cstr, SBStream s) -> size_t"},
	 { "SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn", _wrap_SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn, METH_VARARGS, "SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn(SBSourceManager self, SBFileSpec file, uint32_t line, uint32_t column, uint32_t context_before, uint32_t context_after, char const * current_line_cstr, SBStream s) -> size_t"},
	 { "SBSourceManager_swigregister", SBSourceManager_swigregister, METH_O, NULL},
	 { "SBSourceManager_swiginit", SBSourceManager_swiginit, METH_VARARGS, NULL},
	 { "new_SBStatisticsOptions", _wrap_new_SBStatisticsOptions, METH_VARARGS, "\n"
		"SBStatisticsOptions()\n"
		"new_SBStatisticsOptions(SBStatisticsOptions rhs) -> SBStatisticsOptions\n"
		""},
	 { "delete_SBStatisticsOptions", _wrap_delete_SBStatisticsOptions, METH_O, "delete_SBStatisticsOptions(SBStatisticsOptions self)"},
	 { "SBStatisticsOptions_SetSummaryOnly", _wrap_SBStatisticsOptions_SetSummaryOnly, METH_VARARGS, "\n"
		"SBStatisticsOptions_SetSummaryOnly(SBStatisticsOptions self, bool b)\n"
		"Sets whether the statistics should only dump a summary.\n"
		""},
	 { "SBStatisticsOptions_GetSummaryOnly", _wrap_SBStatisticsOptions_GetSummaryOnly, METH_O, "\n"
		"SBStatisticsOptions_GetSummaryOnly(SBStatisticsOptions self) -> bool\n"
		"Gets whether the statistics only dump a summary.\n"
		""},
	 { "SBStatisticsOptions_SetIncludeTargets", _wrap_SBStatisticsOptions_SetIncludeTargets, METH_VARARGS, "\n"
		"If true, dump statistics for the targets, including breakpoints,\n"
		"expression evaluations, frame variables, etc.\n"
		"\n"
		"Defaults to true, unless the `SummaryOnly` mode is enabled, in which case\n"
		"this is turned off unless specified.\n"
		"\n"
		"If both `IncludeTargets` and `IncludeModules` are true, a list of module\n"
		"identifiers will be added to the \"targets\" section.\n"
		""},
	 { "SBStatisticsOptions_GetIncludeTargets", _wrap_SBStatisticsOptions_GetIncludeTargets, METH_O, "SBStatisticsOptions_GetIncludeTargets(SBStatisticsOptions self) -> bool"},
	 { "SBStatisticsOptions_SetIncludeModules", _wrap_SBStatisticsOptions_SetIncludeModules, METH_VARARGS, "\n"
		"If true, dump statistics for the modules, including time and size of\n"
		"various aspects of the module and debug information, type system, path,\n"
		"etc.\n"
		"\n"
		"Defaults to true, unless the `SummaryOnly` mode is enabled, in which case\n"
		"this is turned off unless specified.\n"
		"\n"
		"If both `IncludeTargets` and `IncludeModules` are true, a list of module\n"
		"identifiers will be added to the \"targets\" section.\n"
		""},
	 { "SBStatisticsOptions_GetIncludeModules", _wrap_SBStatisticsOptions_GetIncludeModules, METH_O, "SBStatisticsOptions_GetIncludeModules(SBStatisticsOptions self) -> bool"},
	 { "SBStatisticsOptions_SetIncludeTranscript", _wrap_SBStatisticsOptions_SetIncludeTranscript, METH_VARARGS, "\n"
		"If true and the setting `interpreter.save-transcript` is enabled, include\n"
		"a JSON array with all commands the user and/or scripts executed during a\n"
		"debug session.\n"
		"\n"
		"Defaults to false.\n"
		""},
	 { "SBStatisticsOptions_GetIncludeTranscript", _wrap_SBStatisticsOptions_GetIncludeTranscript, METH_O, "SBStatisticsOptions_GetIncludeTranscript(SBStatisticsOptions self) -> bool"},
	 { "SBStatisticsOptions_SetReportAllAvailableDebugInfo", _wrap_SBStatisticsOptions_SetReportAllAvailableDebugInfo, METH_VARARGS, "\n"
		"SBStatisticsOptions_SetReportAllAvailableDebugInfo(SBStatisticsOptions self, bool b)\n"
		"\n"
		"    Sets whether the statistics will force loading all possible debug info.\n"
		""},
	 { "SBStatisticsOptions_GetReportAllAvailableDebugInfo", _wrap_SBStatisticsOptions_GetReportAllAvailableDebugInfo, METH_O, "\n"
		"SBStatisticsOptions_GetReportAllAvailableDebugInfo(SBStatisticsOptions self) -> bool\n"
		"\n"
		"    Gets whether the statistics will force loading all possible debug info.\n"
		""},
	 { "SBStatisticsOptions_swigregister", SBStatisticsOptions_swigregister, METH_O, NULL},
	 { "SBStatisticsOptions_swiginit", SBStatisticsOptions_swiginit, METH_VARARGS, NULL},
	 { "new_SBStream", _wrap_new_SBStream, METH_NOARGS, "new_SBStream() -> SBStream"},
	 { "delete_SBStream", _wrap_delete_SBStream, METH_O, "delete_SBStream(SBStream self)"},
	 { "SBStream___nonzero__", _wrap_SBStream___nonzero__, METH_O, "SBStream___nonzero__(SBStream self) -> bool"},
	 { "SBStream_IsValid", _wrap_SBStream_IsValid, METH_O, "SBStream_IsValid(SBStream self) -> bool"},
	 { "SBStream_GetData", _wrap_SBStream_GetData, METH_O, "\n"
		"SBStream_GetData(SBStream self) -> char const *\n"
		"\n"
		"    If this stream is not redirected to a file, it will maintain a local\n"
		"    cache for the stream data which can be accessed using this accessor.\n"
		""},
	 { "SBStream_GetSize", _wrap_SBStream_GetSize, METH_O, "\n"
		"SBStream_GetSize(SBStream self) -> size_t\n"
		"\n"
		"    If this stream is not redirected to a file, it will maintain a local\n"
		"    cache for the stream output whose length can be accessed using this\n"
		"    accessor.\n"
		""},
	 { "SBStream_Print", _wrap_SBStream_Print, METH_VARARGS, "SBStream_Print(SBStream self, char const * str)"},
	 { "SBStream_RedirectToFile", _wrap_SBStream_RedirectToFile, METH_VARARGS, "\n"
		"SBStream_RedirectToFile(SBStream self, char const * path, bool append)\n"
		"SBStream_RedirectToFile(SBStream self, SBFile file)\n"
		"SBStream_RedirectToFile(SBStream self, lldb::FileSP file)\n"
		""},
	 { "SBStream_RedirectToFileDescriptor", _wrap_SBStream_RedirectToFileDescriptor, METH_VARARGS, "SBStream_RedirectToFileDescriptor(SBStream self, int fd, bool transfer_fh_ownership)"},
	 { "SBStream_Clear", _wrap_SBStream_Clear, METH_O, "\n"
		"SBStream_Clear(SBStream self)\n"
		"\n"
		"    If the stream is redirected to a file, forget about the file and if\n"
		"    ownership of the file was transferred to this object, close the file.\n"
		"    If the stream is backed by a local cache, clear this cache.\n"
		""},
	 { "SBStream_RedirectToFileHandle", _wrap_SBStream_RedirectToFileHandle, METH_VARARGS, "DEPRECATED, use RedirectToFile"},
	 { "SBStream_write", _wrap_SBStream_write, METH_VARARGS, "SBStream_write(SBStream self, char const * str)"},
	 { "SBStream_flush", _wrap_SBStream_flush, METH_O, "SBStream_flush(SBStream self)"},
	 { "SBStream_swigregister", SBStream_swigregister, METH_O, NULL},
	 { "SBStream_swiginit", SBStream_swiginit, METH_VARARGS, NULL},
	 { "new_SBStringList", _wrap_new_SBStringList, METH_VARARGS, "\n"
		"SBStringList()\n"
		"new_SBStringList(SBStringList rhs) -> SBStringList\n"
		""},
	 { "delete_SBStringList", _wrap_delete_SBStringList, METH_O, "delete_SBStringList(SBStringList self)"},
	 { "SBStringList___nonzero__", _wrap_SBStringList___nonzero__, METH_O, "SBStringList___nonzero__(SBStringList self) -> bool"},
	 { "SBStringList_IsValid", _wrap_SBStringList_IsValid, METH_O, "SBStringList_IsValid(SBStringList self) -> bool"},
	 { "SBStringList_AppendString", _wrap_SBStringList_AppendString, METH_VARARGS, "SBStringList_AppendString(SBStringList self, char const * str)"},
	 { "SBStringList_AppendList", _wrap_SBStringList_AppendList, METH_VARARGS, "\n"
		"SBStringList_AppendList(SBStringList self, char const ** strv, int strc)\n"
		"SBStringList_AppendList(SBStringList self, SBStringList strings)\n"
		""},
	 { "SBStringList_GetSize", _wrap_SBStringList_GetSize, METH_O, "SBStringList_GetSize(SBStringList self) -> uint32_t"},
	 { "SBStringList_GetStringAtIndex", _wrap_SBStringList_GetStringAtIndex, METH_VARARGS, "\n"
		"SBStringList_GetStringAtIndex(SBStringList self, size_t idx) -> char const\n"
		"SBStringList_GetStringAtIndex(SBStringList self, size_t idx) -> char const *\n"
		""},
	 { "SBStringList_Clear", _wrap_SBStringList_Clear, METH_O, "SBStringList_Clear(SBStringList self)"},
	 { "SBStringList_swigregister", SBStringList_swigregister, METH_O, NULL},
	 { "SBStringList_swiginit", SBStringList_swiginit, METH_VARARGS, NULL},
	 { "new_SBStructuredData", _wrap_new_SBStructuredData, METH_VARARGS, "\n"
		"SBStructuredData()\n"
		"SBStructuredData(SBStructuredData rhs)\n"
		"new_SBStructuredData(SBScriptObject obj, SBDebugger debugger) -> SBStructuredData\n"
		""},
	 { "delete_SBStructuredData", _wrap_delete_SBStructuredData, METH_O, "delete_SBStructuredData(SBStructuredData self)"},
	 { "SBStructuredData___nonzero__", _wrap_SBStructuredData___nonzero__, METH_O, "SBStructuredData___nonzero__(SBStructuredData self) -> bool"},
	 { "SBStructuredData_IsValid", _wrap_SBStructuredData_IsValid, METH_O, "SBStructuredData_IsValid(SBStructuredData self) -> bool"},
	 { "SBStructuredData_SetFromJSON", _wrap_SBStructuredData_SetFromJSON, METH_VARARGS, "\n"
		"SBStructuredData_SetFromJSON(SBStructuredData self, SBStream stream) -> SBError\n"
		"SBStructuredData_SetFromJSON(SBStructuredData self, char const * json) -> SBError\n"
		""},
	 { "SBStructuredData_Clear", _wrap_SBStructuredData_Clear, METH_O, "SBStructuredData_Clear(SBStructuredData self)"},
	 { "SBStructuredData_GetAsJSON", _wrap_SBStructuredData_GetAsJSON, METH_VARARGS, "SBStructuredData_GetAsJSON(SBStructuredData self, SBStream stream) -> SBError"},
	 { "SBStructuredData_GetDescription", _wrap_SBStructuredData_GetDescription, METH_VARARGS, "SBStructuredData_GetDescription(SBStructuredData self, SBStream stream) -> SBError"},
	 { "SBStructuredData_GetType", _wrap_SBStructuredData_GetType, METH_O, "Return the type of data in this data structure"},
	 { "SBStructuredData_GetSize", _wrap_SBStructuredData_GetSize, METH_O, "\n"
		"Return the size (i.e. number of elements) in this data structure\n"
		"if it is an array or dictionary type. For other types, 0 will be\n"
		""},
	 { "SBStructuredData_GetKeys", _wrap_SBStructuredData_GetKeys, METH_VARARGS, "\n"
		"Fill keys with the keys in this object and return true if this data\n"
		"structure is a dictionary.  Returns false otherwise.\n"
		""},
	 { "SBStructuredData_GetValueForKey", _wrap_SBStructuredData_GetValueForKey, METH_VARARGS, "\n"
		"Return the value corresponding to a key if this data structure\n"
		"is a dictionary type.\n"
		""},
	 { "SBStructuredData_GetItemAtIndex", _wrap_SBStructuredData_GetItemAtIndex, METH_VARARGS, "\n"
		"Return the value corresponding to an index if this data structure\n"
		"is array.\n"
		""},
	 { "SBStructuredData_GetUnsignedIntegerValue", _wrap_SBStructuredData_GetUnsignedIntegerValue, METH_VARARGS, "Return the integer value if this data structure is an integer type."},
	 { "SBStructuredData_GetSignedIntegerValue", _wrap_SBStructuredData_GetSignedIntegerValue, METH_VARARGS, "Return the integer value if this data structure is an integer type."},
	 { "SBStructuredData_GetIntegerValue", _wrap_SBStructuredData_GetIntegerValue, METH_VARARGS, "SBStructuredData_GetIntegerValue(SBStructuredData self, uint64_t fail_value=0) -> uint64_t"},
	 { "SBStructuredData_GetFloatValue", _wrap_SBStructuredData_GetFloatValue, METH_VARARGS, "\n"
		"Return the floating point value if this data structure is a floating\n"
		"type.\n"
		""},
	 { "SBStructuredData_GetBooleanValue", _wrap_SBStructuredData_GetBooleanValue, METH_VARARGS, "Return the boolean value if this data structure is a boolean type."},
	 { "SBStructuredData_GetStringValue", _wrap_SBStructuredData_GetStringValue, METH_VARARGS, "\n"
		"Provides the string value if this data structure is a string type.\n"
		"\n"
		":type dst: string, out\n"
		":param dst:\n"
		"        pointer where the string value will be written. In case it is null,\n"
		"        nothing will be written at *dst*.\n"
		"\n"
		":type dst_len: int, in\n"
		":param dst_len:\n"
		"        max number of characters that can be written at *dst*. In case it is\n"
		"        zero, nothing will be written at *dst*. If this length is not enough\n"
		"        to write the complete string value, (*dst_len* - 1) bytes of the\n"
		"        string value will be written at *dst* followed by a null character.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"        Returns the byte size needed to completely write the string value at\n"
		"        *dst* in all cases.\n"
		""},
	 { "SBStructuredData_GetGenericValue", _wrap_SBStructuredData_GetGenericValue, METH_O, "Return the generic pointer if this data structure is a generic type."},
	 { "SBStructuredData_SetValueForKey", _wrap_SBStructuredData_SetValueForKey, METH_VARARGS, "\n"
		"Set the value corresponding to a key. If this data structure\n"
		"is not a dictionary type, reset the type to be dictionary and overwrite\n"
		"the previous data.\n"
		""},
	 { "SBStructuredData_SetUnsignedIntegerValue", _wrap_SBStructuredData_SetUnsignedIntegerValue, METH_VARARGS, "\n"
		"Change the type to unsigned integer and overwrite the previous data with\n"
		"the new value.\n"
		""},
	 { "SBStructuredData_SetSignedIntegerValue", _wrap_SBStructuredData_SetSignedIntegerValue, METH_VARARGS, "\n"
		"Change the type to signed integer and overwrite the previous data with\n"
		"the new value.\n"
		""},
	 { "SBStructuredData_SetFloatValue", _wrap_SBStructuredData_SetFloatValue, METH_VARARGS, "\n"
		"Change the type to float and overwrite the previous data with the new\n"
		"value.\n"
		""},
	 { "SBStructuredData_SetBooleanValue", _wrap_SBStructuredData_SetBooleanValue, METH_VARARGS, "\n"
		"Change the type to boolean and overwrite the previous data with the new\n"
		"value.\n"
		""},
	 { "SBStructuredData_SetStringValue", _wrap_SBStructuredData_SetStringValue, METH_VARARGS, "\n"
		"Change the type to string and overwrite the previous data with the new\n"
		"value.\n"
		""},
	 { "SBStructuredData_SetGenericValue", _wrap_SBStructuredData_SetGenericValue, METH_VARARGS, "\n"
		"Change the type to generic and overwrite the previous data with the new\n"
		"value.\n"
		""},
	 { "SBStructuredData___repr__", _wrap_SBStructuredData___repr__, METH_O, "SBStructuredData___repr__(SBStructuredData self) -> std::string"},
	 { "SBStructuredData_swigregister", SBStructuredData_swigregister, METH_O, NULL},
	 { "SBStructuredData_swiginit", SBStructuredData_swiginit, METH_VARARGS, NULL},
	 { "delete_SBSymbol", _wrap_delete_SBSymbol, METH_O, "delete_SBSymbol(SBSymbol self)"},
	 { "new_SBSymbol", _wrap_new_SBSymbol, METH_VARARGS, "\n"
		"SBSymbol()\n"
		"new_SBSymbol(SBSymbol rhs) -> SBSymbol\n"
		""},
	 { "SBSymbol___nonzero__", _wrap_SBSymbol___nonzero__, METH_O, "SBSymbol___nonzero__(SBSymbol self) -> bool"},
	 { "SBSymbol_IsValid", _wrap_SBSymbol_IsValid, METH_O, "SBSymbol_IsValid(SBSymbol self) -> bool"},
	 { "SBSymbol_GetName", _wrap_SBSymbol_GetName, METH_O, "SBSymbol_GetName(SBSymbol self) -> char const *"},
	 { "SBSymbol_GetDisplayName", _wrap_SBSymbol_GetDisplayName, METH_O, "SBSymbol_GetDisplayName(SBSymbol self) -> char const *"},
	 { "SBSymbol_GetMangledName", _wrap_SBSymbol_GetMangledName, METH_O, "SBSymbol_GetMangledName(SBSymbol self) -> char const *"},
	 { "SBSymbol_GetBaseName", _wrap_SBSymbol_GetBaseName, METH_O, "SBSymbol_GetBaseName(SBSymbol self) -> char const *"},
	 { "SBSymbol_GetInstructions", _wrap_SBSymbol_GetInstructions, METH_VARARGS, "\n"
		"SBSymbol_GetInstructions(SBSymbol self, SBTarget target) -> SBInstructionList\n"
		"SBSymbol_GetInstructions(SBSymbol self, SBTarget target, char const * flavor_string) -> SBInstructionList\n"
		""},
	 { "SBSymbol_GetStartAddress", _wrap_SBSymbol_GetStartAddress, METH_O, "\n"
		"Get the start address of this symbol\n"
		"\n"
		":rtype: :py:class:`SBAddress`\n"
		":return: \n"
		"      If the symbol's value is not an address, an invalid SBAddress object\n"
		"      will be returned. If the symbol's value is an address, a valid SBAddress\n"
		"      object will be returned.\n"
		""},
	 { "SBSymbol_GetEndAddress", _wrap_SBSymbol_GetEndAddress, METH_O, "\n"
		"Get the end address of this symbol\n"
		"\n"
		":rtype: :py:class:`SBAddress`\n"
		":return: \n"
		"      If the symbol's value is not an address, an invalid SBAddress object\n"
		"      will be returned. If the symbol's value is an address, a valid SBAddress\n"
		"      object will be returned.\n"
		""},
	 { "SBSymbol_GetValue", _wrap_SBSymbol_GetValue, METH_O, "\n"
		"Get the raw value of a symbol.\n"
		"\n"
		"This accessor allows direct access to the symbol's value from the symbol\n"
		"table regardless of what the value is. The value can be a file address or\n"
		"it can be an integer value that depends on what the symbol's type is. Some\n"
		"symbol values are not addresses, but absolute values or integer values\n"
		"that can be mean different things. The GetStartAddress() accessor will\n"
		"only return a valid SBAddress if the symbol's value is an address, so this\n"
		"accessor provides a way to access the symbol's value when the value is\n"
		"not an address.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"      Returns the raw integer value of a symbol from the symbol table.\n"
		""},
	 { "SBSymbol_GetSize", _wrap_SBSymbol_GetSize, METH_O, "\n"
		"Get the size of the symbol.\n"
		"\n"
		"This accessor allows direct access to the symbol's size from the symbol\n"
		"table regardless of what the value is (address or integer value).\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"      Returns the size of a symbol from the symbol table.\n"
		""},
	 { "SBSymbol_GetPrologueByteSize", _wrap_SBSymbol_GetPrologueByteSize, METH_O, "SBSymbol_GetPrologueByteSize(SBSymbol self) -> uint32_t"},
	 { "SBSymbol_GetType", _wrap_SBSymbol_GetType, METH_O, "SBSymbol_GetType(SBSymbol self) -> lldb::SymbolType"},
	 { "SBSymbol_GetID", _wrap_SBSymbol_GetID, METH_O, "\n"
		"Get the ID of this symbol, usually the original symbol table index.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"        LLDB_INVALID_SYMBOL_ID if this object does not contain a valid symbol\n"
		"        object. Otherwise, Returns a valid symbol ID.\n"
		""},
	 { "SBSymbol___eq__", _wrap_SBSymbol___eq__, METH_VARARGS, "SBSymbol___eq__(SBSymbol self, SBSymbol rhs) -> bool"},
	 { "SBSymbol___ne__", _wrap_SBSymbol___ne__, METH_VARARGS, "SBSymbol___ne__(SBSymbol self, SBSymbol rhs) -> bool"},
	 { "SBSymbol_GetDescription", _wrap_SBSymbol_GetDescription, METH_VARARGS, "SBSymbol_GetDescription(SBSymbol self, SBStream description) -> bool"},
	 { "SBSymbol_IsExternal", _wrap_SBSymbol_IsExternal, METH_O, "SBSymbol_IsExternal(SBSymbol self) -> bool"},
	 { "SBSymbol_IsSynthetic", _wrap_SBSymbol_IsSynthetic, METH_O, "SBSymbol_IsSynthetic(SBSymbol self) -> bool"},
	 { "SBSymbol_IsDebug", _wrap_SBSymbol_IsDebug, METH_O, "Returns true if the symbol is a debug symbol."},
	 { "SBSymbol_GetTypeAsString", _wrap_SBSymbol_GetTypeAsString, METH_O, "Get the string representation of a symbol type."},
	 { "SBSymbol_GetTypeFromString", _wrap_SBSymbol_GetTypeFromString, METH_O, "Get the symbol type from a string representation."},
	 { "SBSymbol___repr__", _wrap_SBSymbol___repr__, METH_O, "SBSymbol___repr__(SBSymbol self) -> std::string"},
	 { "SBSymbol_swigregister", SBSymbol_swigregister, METH_O, NULL},
	 { "SBSymbol_swiginit", SBSymbol_swiginit, METH_VARARGS, NULL},
	 { "new_SBSymbolContext", _wrap_new_SBSymbolContext, METH_VARARGS, "\n"
		"SBSymbolContext()\n"
		"new_SBSymbolContext(SBSymbolContext rhs) -> SBSymbolContext\n"
		""},
	 { "delete_SBSymbolContext", _wrap_delete_SBSymbolContext, METH_O, "delete_SBSymbolContext(SBSymbolContext self)"},
	 { "SBSymbolContext___nonzero__", _wrap_SBSymbolContext___nonzero__, METH_O, "SBSymbolContext___nonzero__(SBSymbolContext self) -> bool"},
	 { "SBSymbolContext_IsValid", _wrap_SBSymbolContext_IsValid, METH_O, "SBSymbolContext_IsValid(SBSymbolContext self) -> bool"},
	 { "SBSymbolContext_GetModule", _wrap_SBSymbolContext_GetModule, METH_O, "SBSymbolContext_GetModule(SBSymbolContext self) -> SBModule"},
	 { "SBSymbolContext_GetCompileUnit", _wrap_SBSymbolContext_GetCompileUnit, METH_O, "SBSymbolContext_GetCompileUnit(SBSymbolContext self) -> SBCompileUnit"},
	 { "SBSymbolContext_GetFunction", _wrap_SBSymbolContext_GetFunction, METH_O, "SBSymbolContext_GetFunction(SBSymbolContext self) -> SBFunction"},
	 { "SBSymbolContext_GetBlock", _wrap_SBSymbolContext_GetBlock, METH_O, "SBSymbolContext_GetBlock(SBSymbolContext self) -> SBBlock"},
	 { "SBSymbolContext_GetLineEntry", _wrap_SBSymbolContext_GetLineEntry, METH_O, "SBSymbolContext_GetLineEntry(SBSymbolContext self) -> SBLineEntry"},
	 { "SBSymbolContext_GetSymbol", _wrap_SBSymbolContext_GetSymbol, METH_O, "SBSymbolContext_GetSymbol(SBSymbolContext self) -> SBSymbol"},
	 { "SBSymbolContext_SetModule", _wrap_SBSymbolContext_SetModule, METH_VARARGS, "SBSymbolContext_SetModule(SBSymbolContext self, SBModule module)"},
	 { "SBSymbolContext_SetCompileUnit", _wrap_SBSymbolContext_SetCompileUnit, METH_VARARGS, "SBSymbolContext_SetCompileUnit(SBSymbolContext self, SBCompileUnit compile_unit)"},
	 { "SBSymbolContext_SetFunction", _wrap_SBSymbolContext_SetFunction, METH_VARARGS, "SBSymbolContext_SetFunction(SBSymbolContext self, SBFunction function)"},
	 { "SBSymbolContext_SetBlock", _wrap_SBSymbolContext_SetBlock, METH_VARARGS, "SBSymbolContext_SetBlock(SBSymbolContext self, SBBlock block)"},
	 { "SBSymbolContext_SetLineEntry", _wrap_SBSymbolContext_SetLineEntry, METH_VARARGS, "SBSymbolContext_SetLineEntry(SBSymbolContext self, SBLineEntry line_entry)"},
	 { "SBSymbolContext_SetSymbol", _wrap_SBSymbolContext_SetSymbol, METH_VARARGS, "SBSymbolContext_SetSymbol(SBSymbolContext self, SBSymbol symbol)"},
	 { "SBSymbolContext_GetParentOfInlinedScope", _wrap_SBSymbolContext_GetParentOfInlinedScope, METH_VARARGS, "SBSymbolContext_GetParentOfInlinedScope(SBSymbolContext self, SBAddress curr_frame_pc, SBAddress parent_frame_addr) -> SBSymbolContext"},
	 { "SBSymbolContext_GetDescription", _wrap_SBSymbolContext_GetDescription, METH_VARARGS, "SBSymbolContext_GetDescription(SBSymbolContext self, SBStream description) -> bool"},
	 { "SBSymbolContext___repr__", _wrap_SBSymbolContext___repr__, METH_O, "SBSymbolContext___repr__(SBSymbolContext self) -> std::string"},
	 { "SBSymbolContext_swigregister", SBSymbolContext_swigregister, METH_O, NULL},
	 { "SBSymbolContext_swiginit", SBSymbolContext_swiginit, METH_VARARGS, NULL},
	 { "new_SBSymbolContextList", _wrap_new_SBSymbolContextList, METH_VARARGS, "\n"
		"SBSymbolContextList()\n"
		"new_SBSymbolContextList(SBSymbolContextList rhs) -> SBSymbolContextList\n"
		""},
	 { "delete_SBSymbolContextList", _wrap_delete_SBSymbolContextList, METH_O, "delete_SBSymbolContextList(SBSymbolContextList self)"},
	 { "SBSymbolContextList___nonzero__", _wrap_SBSymbolContextList___nonzero__, METH_O, "SBSymbolContextList___nonzero__(SBSymbolContextList self) -> bool"},
	 { "SBSymbolContextList_IsValid", _wrap_SBSymbolContextList_IsValid, METH_O, "SBSymbolContextList_IsValid(SBSymbolContextList self) -> bool"},
	 { "SBSymbolContextList_GetSize", _wrap_SBSymbolContextList_GetSize, METH_O, "SBSymbolContextList_GetSize(SBSymbolContextList self) -> uint32_t"},
	 { "SBSymbolContextList_GetContextAtIndex", _wrap_SBSymbolContextList_GetContextAtIndex, METH_VARARGS, "SBSymbolContextList_GetContextAtIndex(SBSymbolContextList self, uint32_t idx) -> SBSymbolContext"},
	 { "SBSymbolContextList_GetDescription", _wrap_SBSymbolContextList_GetDescription, METH_VARARGS, "SBSymbolContextList_GetDescription(SBSymbolContextList self, SBStream description) -> bool"},
	 { "SBSymbolContextList_Append", _wrap_SBSymbolContextList_Append, METH_VARARGS, "\n"
		"SBSymbolContextList_Append(SBSymbolContextList self, SBSymbolContext sc)\n"
		"SBSymbolContextList_Append(SBSymbolContextList self, SBSymbolContextList sc_list)\n"
		""},
	 { "SBSymbolContextList_Clear", _wrap_SBSymbolContextList_Clear, METH_O, "SBSymbolContextList_Clear(SBSymbolContextList self)"},
	 { "SBSymbolContextList___repr__", _wrap_SBSymbolContextList___repr__, METH_O, "SBSymbolContextList___repr__(SBSymbolContextList self) -> std::string"},
	 { "SBSymbolContextList_swigregister", SBSymbolContextList_swigregister, METH_O, NULL},
	 { "SBSymbolContextList_swiginit", SBSymbolContextList_swiginit, METH_VARARGS, NULL},
	 { "new_SBTarget", _wrap_new_SBTarget, METH_VARARGS, "\n"
		"SBTarget()\n"
		"new_SBTarget(SBTarget rhs) -> SBTarget\n"
		""},
	 { "delete_SBTarget", _wrap_delete_SBTarget, METH_O, "delete_SBTarget(SBTarget self)"},
	 { "SBTarget___nonzero__", _wrap_SBTarget___nonzero__, METH_O, "SBTarget___nonzero__(SBTarget self) -> bool"},
	 { "SBTarget_IsValid", _wrap_SBTarget_IsValid, METH_O, "SBTarget_IsValid(SBTarget self) -> bool"},
	 { "SBTarget_EventIsTargetEvent", _wrap_SBTarget_EventIsTargetEvent, METH_O, "SBTarget_EventIsTargetEvent(SBEvent event) -> bool"},
	 { "SBTarget_GetTargetFromEvent", _wrap_SBTarget_GetTargetFromEvent, METH_O, "SBTarget_GetTargetFromEvent(SBEvent event) -> SBTarget"},
	 { "SBTarget_GetCreatedTargetFromEvent", _wrap_SBTarget_GetCreatedTargetFromEvent, METH_O, "\n"
		"For eBroadcastBitNewTargetCreated events, returns the newly created\n"
		"target. For other event types, returns an invalid SBTarget.\n"
		""},
	 { "SBTarget_GetNumModulesFromEvent", _wrap_SBTarget_GetNumModulesFromEvent, METH_O, "SBTarget_GetNumModulesFromEvent(SBEvent event) -> uint32_t"},
	 { "SBTarget_GetModuleAtIndexFromEvent", _wrap_SBTarget_GetModuleAtIndexFromEvent, METH_VARARGS, "SBTarget_GetModuleAtIndexFromEvent(uint32_t const idx, SBEvent event) -> SBModule"},
	 { "SBTarget_GetBroadcasterClassName", _wrap_SBTarget_GetBroadcasterClassName, METH_NOARGS, "SBTarget_GetBroadcasterClassName() -> char const *"},
	 { "SBTarget_GetProcess", _wrap_SBTarget_GetProcess, METH_O, "SBTarget_GetProcess(SBTarget self) -> SBProcess"},
	 { "SBTarget_SetCollectingStats", _wrap_SBTarget_SetCollectingStats, METH_VARARGS, "\n"
		"Sets whether we should collect statistics on lldb or not.\n"
		"\n"
		":type v: boolean, in\n"
		":param v:\n"
		"        A boolean to control the collection.\n"
		""},
	 { "SBTarget_GetCollectingStats", _wrap_SBTarget_GetCollectingStats, METH_O, "\n"
		"Returns whether statistics collection are enabled.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"        true if statistics are currently being collected, false\n"
		"        otherwise.\n"
		""},
	 { "SBTarget_GetStatistics", _wrap_SBTarget_GetStatistics, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		"Returns a dump of the collected statistics.\n"
		"\n"
		":rtype: :py:class:`SBStructuredData`\n"
		":return: \n"
		"        A SBStructuredData with the statistics collected.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		"Returns a dump of the collected statistics.\n"
		"\n"
		":type options: :py:class:`SBStatisticsOptions`, in\n"
		":param options:\n"
		"      An objects object that contains all options for the statistics dumping.\n"
		"\n"
		":rtype: :py:class:`SBStructuredData`\n"
		":return: \n"
		"        A SBStructuredData with the statistics collected.\n"
		""},
	 { "SBTarget_ResetStatistics", _wrap_SBTarget_ResetStatistics, METH_O, "\n"
		"Reset the statistics collected for this target.\n"
		"This includes clearing symbol table and debug info parsing/index time for\n"
		"all modules, breakpoint resolve time and target statistics.\n"
		""},
	 { "SBTarget_GetPlatform", _wrap_SBTarget_GetPlatform, METH_O, "\n"
		"SBTarget_GetPlatform(SBTarget self) -> SBPlatform\n"
		"\n"
		"    Return the platform object associated with the target.\n"
		"\n"
		"    After return, the platform object should be checked for\n"
		"    validity.\n"
		"\n"
		"    @return\n"
		"        A platform object.\n"
		""},
	 { "SBTarget_GetEnvironment", _wrap_SBTarget_GetEnvironment, METH_O, "\n"
		"Return the environment variables that would be used to launch a new\n"
		"process.\n"
		"\n"
		":rtype: :py:class:`SBEnvironment`\n"
		":return: \n"
		"        An lldb::SBEnvironment object which is a copy of the target's\n"
		"        environment.\n"
		""},
	 { "SBTarget_Install", _wrap_SBTarget_Install, METH_O, "\n"
		"SBTarget_Install(SBTarget self) -> SBError\n"
		"\n"
		"    Install any binaries that need to be installed.\n"
		"\n"
		"    This function does nothing when debugging on the host system.\n"
		"    When connected to remote platforms, the target's main executable\n"
		"    and any modules that have their install path set will be\n"
		"    installed on the remote platform. If the main executable doesn't\n"
		"    have an install location set, it will be installed in the remote\n"
		"    platform's working directory.\n"
		"\n"
		"    @return\n"
		"        An error describing anything that went wrong during\n"
		"        installation.\n"
		""},
	 { "SBTarget_LoadCore", _wrap_SBTarget_LoadCore, METH_VARARGS, "\n"
		"SBTarget_LoadCore(SBTarget self, char const * core_file) -> SBProcess\n"
		"SBTarget_LoadCore(SBTarget self, char const * core_file, SBError error) -> SBProcess\n"
		"\n"
		"    Load a core file\n"
		"\n"
		"    @param[in] core_file\n"
		"        File path of the core dump.\n"
		"\n"
		"    @param[out] error\n"
		"        An error explaining what went wrong if the operation fails.\n"
		"        (Optional)\n"
		"\n"
		"    @return\n"
		"         A process object for the newly created core file.\n"
		"\n"
		"    For example,\n"
		"\n"
		"        process = target.LoadCore('./a.out.core')\n"
		"\n"
		"    loads a new core file and returns the process object.\n"
		""},
	 { "SBTarget_LaunchSimple", _wrap_SBTarget_LaunchSimple, METH_VARARGS, "\n"
		"SBTarget_LaunchSimple(SBTarget self, char const ** argv, char const ** envp, char const * working_directory) -> SBProcess\n"
		"\n"
		"    Launch a new process with sensible defaults.\n"
		"\n"
		"    :param argv: The argument array.\n"
		"    :param envp: The environment array.\n"
		"    :param working_directory: The working directory to have the child process run in\n"
		"    :return: The newly created process.\n"
		"    :rtype: SBProcess\n"
		"\n"
		"    A pseudo terminal will be used as stdin/stdout/stderr.\n"
		"    No launch flags are passed and the target's debuger is used as a listener.\n"
		"\n"
		"    For example, ::\n"
		"\n"
		"        process = target.LaunchSimple(['X', 'Y', 'Z'], None, os.getcwd())\n"
		"\n"
		"    launches a new process by passing 'X', 'Y', 'Z' as the args to the\n"
		"    executable.\n"
		""},
	 { "SBTarget_Launch", _wrap_SBTarget_Launch, METH_VARARGS, "\n"
		"SBTarget_Launch(SBTarget self, SBListener listener, char const ** argv, char const ** envp, char const * stdin_path, char const * stdout_path, char const * stderr_path, char const * working_directory, uint32_t launch_flags, bool stop_at_entry, SBError error) -> SBProcess\n"
		"SBTarget_Launch(SBTarget self, SBLaunchInfo launch_info, SBError error) -> SBProcess\n"
		"\n"
		"    Launch a new process.\n"
		"\n"
		"    Launch a new process by spawning a new process using the\n"
		"    target object's executable module's file as the file to launch.\n"
		"    Arguments are given in argv, and the environment variables\n"
		"    are in envp. Standard input and output files can be\n"
		"    optionally re-directed to stdin_path, stdout_path, and\n"
		"    stderr_path.\n"
		"\n"
		"    @param[in] listener\n"
		"        An optional listener that will receive all process events.\n"
		"        If listener is valid then listener will listen to all\n"
		"        process events. If not valid, then this target's debugger\n"
		"        (SBTarget::GetDebugger()) will listen to all process events.\n"
		"\n"
		"    @param[in] argv\n"
		"        The argument array.\n"
		"\n"
		"    @param[in] envp\n"
		"        The environment array.\n"
		"\n"
		"    @param[in] launch_flags\n"
		"        Flags to modify the launch (@see lldb::LaunchFlags)\n"
		"\n"
		"    @param[in] stdin_path\n"
		"        The path to use when re-directing the STDIN of the new\n"
		"        process. If all stdXX_path arguments are NULL, a pseudo\n"
		"        terminal will be used.\n"
		"\n"
		"    @param[in] stdout_path\n"
		"        The path to use when re-directing the STDOUT of the new\n"
		"        process. If all stdXX_path arguments are NULL, a pseudo\n"
		"        terminal will be used.\n"
		"\n"
		"    @param[in] stderr_path\n"
		"        The path to use when re-directing the STDERR of the new\n"
		"        process. If all stdXX_path arguments are NULL, a pseudo\n"
		"        terminal will be used.\n"
		"\n"
		"    @param[in] working_directory\n"
		"        The working directory to have the child process run in\n"
		"\n"
		"    @param[in] launch_flags\n"
		"        Some launch options specified by logical OR'ing\n"
		"        lldb::LaunchFlags enumeration values together.\n"
		"\n"
		"    @param[in] stop_at_entry\n"
		"        If false do not stop the inferior at the entry point.\n"
		"\n"
		"    @param[out]\n"
		"        An error object. Contains the reason if there is some failure.\n"
		"\n"
		"    @return\n"
		"         A process object for the newly created process.\n"
		"\n"
		"    For example,\n"
		"\n"
		"        process = target.Launch(self.dbg.GetListener(), None, None,\n"
		"                                None, '/tmp/stdout.txt', None,\n"
		"                                None, 0, False, error)\n"
		"\n"
		"    launches a new process by passing nothing for both the args and the envs\n"
		"    and redirect the standard output of the inferior to the /tmp/stdout.txt\n"
		"    file. It does not specify a working directory so that the debug server\n"
		"    will use its idea of what the current working directory is for the\n"
		"    inferior. Also, we ask the debugger not to stop the inferior at the\n"
		"    entry point. If no breakpoint is specified for the inferior, it should\n"
		"    run to completion if no user interaction is required.\n"
		""},
	 { "SBTarget_Attach", _wrap_SBTarget_Attach, METH_VARARGS, "SBTarget_Attach(SBTarget self, SBAttachInfo attach_info, SBError error) -> SBProcess"},
	 { "SBTarget_AttachToProcessWithID", _wrap_SBTarget_AttachToProcessWithID, METH_VARARGS, "\n"
		"SBTarget_AttachToProcessWithID(SBTarget self, SBListener listener, lldb::pid_t pid, SBError error) -> SBProcess\n"
		"\n"
		"    Attach to process with pid.\n"
		"\n"
		"    @param[in] listener\n"
		"        An optional listener that will receive all process events.\n"
		"        If listener is valid then listener will listen to all\n"
		"        process events. If not valid, then this target's debugger\n"
		"        (SBTarget::GetDebugger()) will listen to all process events.\n"
		"\n"
		"    @param[in] pid\n"
		"        The process ID to attach to.\n"
		"\n"
		"    @param[out]\n"
		"        An error explaining what went wrong if attach fails.\n"
		"\n"
		"    @return\n"
		"         A process object for the attached process.\n"
		""},
	 { "SBTarget_AttachToProcessWithName", _wrap_SBTarget_AttachToProcessWithName, METH_VARARGS, "\n"
		"SBTarget_AttachToProcessWithName(SBTarget self, SBListener listener, char const * name, bool wait_for, SBError error) -> SBProcess\n"
		"\n"
		"    Attach to process with name.\n"
		"\n"
		"    @param[in] listener\n"
		"        An optional listener that will receive all process events.\n"
		"        If listener is valid then listener will listen to all\n"
		"        process events. If not valid, then this target's debugger\n"
		"        (SBTarget::GetDebugger()) will listen to all process events.\n"
		"\n"
		"    @param[in] name\n"
		"        Basename of process to attach to.\n"
		"\n"
		"    @param[in] wait_for\n"
		"        If true wait for a new instance of 'name' to be launched.\n"
		"\n"
		"    @param[out]\n"
		"        An error explaining what went wrong if attach fails.\n"
		"\n"
		"    @return\n"
		"         A process object for the attached process.\n"
		""},
	 { "SBTarget_ConnectRemote", _wrap_SBTarget_ConnectRemote, METH_VARARGS, "\n"
		"SBTarget_ConnectRemote(SBTarget self, SBListener listener, char const * url, char const * plugin_name, SBError error) -> SBProcess\n"
		"\n"
		"    Connect to a remote debug server with url.\n"
		"\n"
		"    @param[in] listener\n"
		"        An optional listener that will receive all process events.\n"
		"        If listener is valid then listener will listen to all\n"
		"        process events. If not valid, then this target's debugger\n"
		"        (SBTarget::GetDebugger()) will listen to all process events.\n"
		"\n"
		"    @param[in] url\n"
		"        The url to connect to, e.g., 'connect://localhost:12345'.\n"
		"\n"
		"    @param[in] plugin_name\n"
		"        The plugin name to be used; can be NULL.\n"
		"\n"
		"    @param[out]\n"
		"        An error explaining what went wrong if the connect fails.\n"
		"\n"
		"    @return\n"
		"         A process object for the connected process.\n"
		""},
	 { "SBTarget_GetExecutable", _wrap_SBTarget_GetExecutable, METH_O, "SBTarget_GetExecutable(SBTarget self) -> SBFileSpec"},
	 { "SBTarget_AppendImageSearchPath", _wrap_SBTarget_AppendImageSearchPath, METH_VARARGS, "\n"
		"SBTarget_AppendImageSearchPath(SBTarget self, char const * _from, char const * to, SBError error)\n"
		"\n"
		"    Append the path mapping (from -> to) to the target's paths mapping list.\n"
		""},
	 { "SBTarget_AddModule", _wrap_SBTarget_AddModule, METH_VARARGS, "\n"
		"SBTarget_AddModule(SBTarget self, SBModule module) -> bool\n"
		"SBTarget_AddModule(SBTarget self, char const * path, char const * triple, char const * uuid) -> SBModule\n"
		"SBTarget_AddModule(SBTarget self, char const * path, char const * triple, char const * uuid_cstr, char const * symfile) -> SBModule\n"
		"SBTarget_AddModule(SBTarget self, SBModuleSpec module_spec) -> SBModule\n"
		""},
	 { "SBTarget_GetNumModules", _wrap_SBTarget_GetNumModules, METH_O, "SBTarget_GetNumModules(SBTarget self) -> uint32_t"},
	 { "SBTarget_GetModuleAtIndex", _wrap_SBTarget_GetModuleAtIndex, METH_VARARGS, "SBTarget_GetModuleAtIndex(SBTarget self, uint32_t idx) -> SBModule"},
	 { "SBTarget_RemoveModule", _wrap_SBTarget_RemoveModule, METH_VARARGS, "SBTarget_RemoveModule(SBTarget self, SBModule module) -> bool"},
	 { "SBTarget_GetDebugger", _wrap_SBTarget_GetDebugger, METH_O, "SBTarget_GetDebugger(SBTarget self) -> SBDebugger"},
	 { "SBTarget_FindModule", _wrap_SBTarget_FindModule, METH_VARARGS, "\n"
		"Find a module with the given module specification.\n"
		"\n"
		":type module_spec: :py:class:`SBModuleSpec`, in\n"
		":param module_spec:\n"
		"        A lldb::SBModuleSpec object that contains module specification.\n"
		"\n"
		":rtype: :py:class:`SBModule`\n"
		":return: \n"
		"        A lldb::SBModule object that represents the found module, or an\n"
		"        invalid SBModule object if no module was found.\n"
		""},
	 { "SBTarget_FindCompileUnits", _wrap_SBTarget_FindCompileUnits, METH_VARARGS, "\n"
		"SBTarget_FindCompileUnits(SBTarget self, SBFileSpec sb_file_spec) -> SBSymbolContextList\n"
		"\n"
		"    Find compile units related to this target and passed source\n"
		"    file.\n"
		"\n"
		"    :param sb_file_spec: A :py:class:`lldb::SBFileSpec` object that contains source file\n"
		"        specification.\n"
		"    :return: The symbol contexts for all the matches.\n"
		"    :rtype: SBSymbolContextList\n"
		""},
	 { "SBTarget_GetByteOrder", _wrap_SBTarget_GetByteOrder, METH_O, "SBTarget_GetByteOrder(SBTarget self) -> lldb::ByteOrder"},
	 { "SBTarget_GetAddressByteSize", _wrap_SBTarget_GetAddressByteSize, METH_O, "SBTarget_GetAddressByteSize(SBTarget self) -> uint32_t"},
	 { "SBTarget_GetTriple", _wrap_SBTarget_GetTriple, METH_O, "SBTarget_GetTriple(SBTarget self) -> char const *"},
	 { "SBTarget_GetArchName", _wrap_SBTarget_GetArchName, METH_O, "SBTarget_GetArchName(SBTarget self) -> char const *"},
	 { "SBTarget_GetABIName", _wrap_SBTarget_GetABIName, METH_O, "SBTarget_GetABIName(SBTarget self) -> char const *"},
	 { "SBTarget_GetLabel", _wrap_SBTarget_GetLabel, METH_O, "SBTarget_GetLabel(SBTarget self) -> char const *"},
	 { "SBTarget_GetGloballyUniqueID", _wrap_SBTarget_GetGloballyUniqueID, METH_O, "\n"
		"Get the globally unique ID for this target. This ID is unique\n"
		"across all debugger instances within the same lldb process.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"        The globally unique ID for this target, or\n"
		"        LLDB_INVALID_GLOBALLY_UNIQUE_TARGET_ID if the target is invalid.\n"
		""},
	 { "SBTarget_GetTargetSessionName", _wrap_SBTarget_GetTargetSessionName, METH_O, "\n"
		"Get the target session name for this target.\n"
		"\n"
		"The target session name provides a meaningful name for IDEs or tools to\n"
		"display to help the user identify the origin and purpose of the target.\n"
		"\n"
		":rtype: string\n"
		":return: \n"
		"        The target session name for this target, or nullptr if the target is\n"
		"        invalid or has no target session name.\n"
		""},
	 { "SBTarget_SetLabel", _wrap_SBTarget_SetLabel, METH_VARARGS, "SBTarget_SetLabel(SBTarget self, char const * label) -> SBError"},
	 { "SBTarget_GetMinimumOpcodeByteSize", _wrap_SBTarget_GetMinimumOpcodeByteSize, METH_O, "\n"
		"Architecture opcode byte size width accessor\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    The minimum size in 8-bit (host) bytes of an opcode.\n"
		""},
	 { "SBTarget_GetMaximumOpcodeByteSize", _wrap_SBTarget_GetMaximumOpcodeByteSize, METH_O, "\n"
		"Architecture opcode byte size width accessor\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"    The maximum size in 8-bit (host) bytes of an opcode.\n"
		""},
	 { "SBTarget_GetDataByteSize", _wrap_SBTarget_GetDataByteSize, METH_O, "\n"
		"SBTarget_GetDataByteSize(SBTarget self) -> uint32_t\n"
		"\n"
		"    Architecture data byte width accessor\n"
		"\n"
		"    :return: The size in 8-bit (host) bytes of a minimum addressable unit from the Architecture's data bus.\n"
		"\n"
		"\n"
		""},
	 { "SBTarget_GetCodeByteSize", _wrap_SBTarget_GetCodeByteSize, METH_O, "\n"
		"SBTarget_GetCodeByteSize(SBTarget self) -> uint32_t\n"
		"\n"
		"    Architecture code byte width accessor.\n"
		"\n"
		"    :return: The size in 8-bit (host) bytes of a minimum addressable unit from the Architecture's code bus.\n"
		"\n"
		"\n"
		""},
	 { "SBTarget_GetMaximumNumberOfChildrenToDisplay", _wrap_SBTarget_GetMaximumNumberOfChildrenToDisplay, METH_O, "\n"
		"Gets the target.max-children-count value\n"
		"It should be used to limit the number of\n"
		"children of large data structures to be displayed.\n"
		""},
	 { "SBTarget_SetSectionLoadAddress", _wrap_SBTarget_SetSectionLoadAddress, METH_VARARGS, "\n"
		"Set the base load address for a module section.\n"
		"\n"
		":type section: :py:class:`SBSection`, in\n"
		":param section:\n"
		"        The section whose base load address will be set within this\n"
		"        target.\n"
		"\n"
		":type section_base_addr: int, in\n"
		":param section_base_addr:\n"
		"        The base address for the section.\n"
		"\n"
		":rtype: :py:class:`SBError`\n"
		":return: \n"
		"         An error to indicate success, fail, and any reason for\n"
		"        failure.\n"
		""},
	 { "SBTarget_ClearSectionLoadAddress", _wrap_SBTarget_ClearSectionLoadAddress, METH_VARARGS, "\n"
		"Clear the base load address for a module section.\n"
		"\n"
		":type section: :py:class:`SBSection`, in\n"
		":param section:\n"
		"        The section whose base load address will be cleared within\n"
		"        this target.\n"
		"\n"
		":rtype: :py:class:`SBError`\n"
		":return: \n"
		"         An error to indicate success, fail, and any reason for\n"
		"        failure.\n"
		""},
	 { "SBTarget_SetModuleLoadAddress", _wrap_SBTarget_SetModuleLoadAddress, METH_VARARGS, "\n"
		"Slide all file addresses for all module sections so that *module*\n"
		"appears to loaded at these slide addresses.\n"
		"\n"
		"When you need all sections within a module to be loaded at a\n"
		"rigid slide from the addresses found in the module object file,\n"
		"this function will allow you to easily and quickly slide all\n"
		"module sections.\n"
		"\n"
		":type module: :py:class:`SBModule`, in\n"
		":param module:\n"
		"        The module to load.\n"
		"\n"
		":type sections_offset: int, in\n"
		":param sections_offset:\n"
		"        An offset that will be applied to all section file addresses\n"
		"        (the virtual addresses found in the object file itself).\n"
		"\n"
		":rtype: :py:class:`SBError`\n"
		":return: \n"
		"        An error to indicate success, fail, and any reason for\n"
		"        failure.\n"
		""},
	 { "SBTarget_ClearModuleLoadAddress", _wrap_SBTarget_ClearModuleLoadAddress, METH_VARARGS, "\n"
		"Clear the section base load addresses for all sections in a module.\n"
		"\n"
		":type module: :py:class:`SBModule`, in\n"
		":param module:\n"
		"        The module to unload.\n"
		"\n"
		":rtype: :py:class:`SBError`\n"
		":return: \n"
		"        An error to indicate success, fail, and any reason for\n"
		"        failure.\n"
		""},
	 { "SBTarget_FindFunctions", _wrap_SBTarget_FindFunctions, METH_VARARGS, "\n"
		"SBTarget_FindFunctions(SBTarget self, char const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> SBSymbolContextList\n"
		"\n"
		"    Find functions by name.\n"
		"\n"
		"    :param name: The name of the function we are looking for.\n"
		"\n"
		"    :param name_type_mask:\n"
		"        A logical OR of one or more FunctionNameType enum bits that\n"
		"        indicate what kind of names should be used when doing the\n"
		"        lookup. Bits include fully qualified names, base names,\n"
		"        C++ methods, or ObjC selectors.\n"
		"        See FunctionNameType for more details.\n"
		"\n"
		"    :return:\n"
		"        A lldb::SBSymbolContextList that gets filled in with all of\n"
		"        the symbol contexts for all the matches.\n"
		""},
	 { "SBTarget_FindFirstGlobalVariable", _wrap_SBTarget_FindFirstGlobalVariable, METH_VARARGS, "\n"
		"SBTarget_FindFirstGlobalVariable(SBTarget self, char const * name) -> SBValue\n"
		"\n"
		"    Find the first global (or static) variable by name.\n"
		"\n"
		"    @param[in] name\n"
		"        The name of the global or static variable we are looking\n"
		"        for.\n"
		"\n"
		"    @return\n"
		"        An SBValue that gets filled in with the found variable (if any).\n"
		""},
	 { "SBTarget_FindGlobalVariables", _wrap_SBTarget_FindGlobalVariables, METH_VARARGS, "\n"
		"SBTarget_FindGlobalVariables(SBTarget self, char const * name, uint32_t max_matches) -> SBValueList\n"
		"SBTarget_FindGlobalVariables(SBTarget self, char const * name, uint32_t max_matches, lldb::MatchType matchtype) -> SBValueList\n"
		"\n"
		"    Find global and static variables by name.\n"
		"\n"
		"    @param[in] name\n"
		"        The name of the global or static variable we are looking\n"
		"        for.\n"
		"\n"
		"    @param[in] max_matches\n"
		"        Allow the number of matches to be limited to max_matches.\n"
		"\n"
		"    @return\n"
		"        A list of matched variables in an SBValueList.\n"
		""},
	 { "SBTarget_FindGlobalFunctions", _wrap_SBTarget_FindGlobalFunctions, METH_VARARGS, "\n"
		"Find global functions by their name with pattern matching.\n"
		"\n"
		":type name: string, in\n"
		":param name:\n"
		"        The pattern to search for global or static variables\n"
		"\n"
		":type max_matches: int, in\n"
		":param max_matches:\n"
		"        Allow the number of matches to be limited to *max_matches*.\n"
		"\n"
		":type matchtype: int, in\n"
		":param matchtype:\n"
		"        The match type to use.\n"
		"\n"
		":rtype: :py:class:`SBSymbolContextList`\n"
		":return: \n"
		"        A list of matched variables in an SBValueList.\n"
		""},
	 { "SBTarget_Clear", _wrap_SBTarget_Clear, METH_O, "SBTarget_Clear(SBTarget self)"},
	 { "SBTarget_ResolveFileAddress", _wrap_SBTarget_ResolveFileAddress, METH_VARARGS, "\n"
		"SBTarget_ResolveFileAddress(SBTarget self, lldb::addr_t file_addr) -> SBAddress\n"
		"\n"
		"    Resolve a current file address into a section offset address.\n"
		"\n"
		"    @param[in] file_addr\n"
		"\n"
		"    @return\n"
		"        An SBAddress which will be valid if...\n"
		""},
	 { "SBTarget_ResolveLoadAddress", _wrap_SBTarget_ResolveLoadAddress, METH_VARARGS, "\n"
		"Resolve a current load address into a section offset address.\n"
		"\n"
		":type vm_addr: int, in\n"
		":param vm_addr:\n"
		"        A virtual address from the current process state that is to\n"
		"        be translated into a section offset address.\n"
		"\n"
		":rtype: :py:class:`SBAddress`\n"
		":return: \n"
		"        An SBAddress which will be valid if *vm_addr* was\n"
		"        successfully resolved into a section offset address, or an\n"
		"        invalid SBAddress if *vm_addr* doesn't resolve to a section\n"
		"        in a module.\n"
		""},
	 { "SBTarget_ResolvePastLoadAddress", _wrap_SBTarget_ResolvePastLoadAddress, METH_VARARGS, "\n"
		"Resolve a current load address into a section offset address\n"
		"using the process stop ID to identify a time in the past.\n"
		"\n"
		":type stop_id: int, in\n"
		":param stop_id:\n"
		"        Each time a process stops, the process stop ID integer gets\n"
		"        incremented. These stop IDs are used to identify past times\n"
		"        and can be used in history objects as a cheap way to store\n"
		"        the time at which the sample was taken. Specifying\n"
		"        UINT32_MAX will always resolve the address using the\n"
		"        currently loaded sections.\n"
		"\n"
		":type vm_addr: int, in\n"
		":param vm_addr:\n"
		"        A virtual address from the current process state that is to\n"
		"        be translated into a section offset address.\n"
		"\n"
		":rtype: :py:class:`SBAddress`\n"
		":return: \n"
		"        An SBAddress which will be valid if *vm_addr* was\n"
		"        successfully resolved into a section offset address, or an\n"
		"        invalid SBAddress if *vm_addr* doesn't resolve to a section\n"
		"        in a module.\n"
		""},
	 { "SBTarget_ResolveSymbolContextForAddress", _wrap_SBTarget_ResolveSymbolContextForAddress, METH_VARARGS, "SBTarget_ResolveSymbolContextForAddress(SBTarget self, SBAddress addr, uint32_t resolve_scope) -> SBSymbolContext"},
	 { "SBTarget_ReadMemory", _wrap_SBTarget_ReadMemory, METH_VARARGS, "\n"
		"SBTarget_ReadMemory(SBTarget self, SBAddress addr, void * buf, SBError error) -> size_t\n"
		"\n"
		"    Read target memory. If a target process is running then memory\n"
		"    is read from here. Otherwise the memory is read from the object\n"
		"    files. For a target whose bytes are sized as a multiple of host\n"
		"    bytes, the data read back will preserve the target's byte order.\n"
		"\n"
		"    @param[in] addr\n"
		"        A target address to read from.\n"
		"\n"
		"    @param[out] buf\n"
		"        The buffer to read memory into.\n"
		"\n"
		"    @param[in] size\n"
		"        The maximum number of host bytes to read in the buffer passed\n"
		"        into this call\n"
		"\n"
		"    @param[out] error\n"
		"        Error information is written here if the memory read fails.\n"
		"\n"
		"    @return\n"
		"        The amount of data read in host bytes.\n"
		""},
	 { "SBTarget_BreakpointCreateByLocation", _wrap_SBTarget_BreakpointCreateByLocation, METH_VARARGS, "\n"
		"SBTarget_BreakpointCreateByLocation(SBTarget self, char const * file, uint32_t line) -> SBBreakpoint\n"
		"SBTarget_BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line) -> SBBreakpoint\n"
		"SBTarget_BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line, lldb::addr_t offset) -> SBBreakpoint\n"
		"SBTarget_BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line, lldb::addr_t offset, SBFileSpecList module_list) -> SBBreakpoint\n"
		"SBTarget_BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line, uint32_t column, lldb::addr_t offset, SBFileSpecList module_list) -> SBBreakpoint\n"
		"SBTarget_BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line, uint32_t column, lldb::addr_t offset, SBFileSpecList module_list, bool move_to_nearest_code) -> SBBreakpoint\n"
		""},
	 { "SBTarget_BreakpointCreateByName", _wrap_SBTarget_BreakpointCreateByName, METH_VARARGS, "\n"
		"SBTarget_BreakpointCreateByName(SBTarget self, char const * symbol_name, char const * module_name=None) -> SBBreakpoint\n"
		"SBTarget_BreakpointCreateByName(SBTarget self, char const * symbol_name, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint\n"
		"SBTarget_BreakpointCreateByName(SBTarget self, char const * symbol_name, uint32_t name_type_mask, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint\n"
		"SBTarget_BreakpointCreateByName(SBTarget self, char const * symbol_name, uint32_t name_type_mask, lldb::LanguageType symbol_language, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint\n"
		"SBTarget_BreakpointCreateByName(SBTarget self, char const * symbol_name, uint32_t name_type_mask, lldb::LanguageType symbol_language, lldb::addr_t offset, bool offset_is_insn_count, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint\n"
		""},
	 { "SBTarget_BreakpointCreateByNames", _wrap_SBTarget_BreakpointCreateByNames, METH_VARARGS, "\n"
		"SBTarget_BreakpointCreateByNames(SBTarget self, char const ** symbol_name, uint32_t name_type_mask, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint\n"
		"SBTarget_BreakpointCreateByNames(SBTarget self, char const ** symbol_name, uint32_t name_type_mask, lldb::LanguageType symbol_language, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint\n"
		"SBTarget_BreakpointCreateByNames(SBTarget self, char const ** symbol_name, uint32_t name_type_mask, lldb::LanguageType symbol_language, lldb::addr_t offset, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint\n"
		""},
	 { "SBTarget_BreakpointCreateByRegex", _wrap_SBTarget_BreakpointCreateByRegex, METH_VARARGS, "\n"
		"SBTarget_BreakpointCreateByRegex(SBTarget self, char const * symbol_name_regex, char const * module_name=None) -> SBBreakpoint\n"
		"SBTarget_BreakpointCreateByRegex(SBTarget self, char const * symbol_name_regex, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint\n"
		"SBTarget_BreakpointCreateByRegex(SBTarget self, char const * symbol_name_regex, lldb::LanguageType symbol_language, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint\n"
		""},
	 { "SBTarget_BreakpointCreateBySourceRegex", _wrap_SBTarget_BreakpointCreateBySourceRegex, METH_VARARGS, "\n"
		"SBTarget_BreakpointCreateBySourceRegex(SBTarget self, char const * source_regex, SBFileSpec source_file, char const * module_name=None) -> SBBreakpoint\n"
		"SBTarget_BreakpointCreateBySourceRegex(SBTarget self, char const * source_regex, SBFileSpecList module_list, SBFileSpecList source_file) -> SBBreakpoint\n"
		"SBTarget_BreakpointCreateBySourceRegex(SBTarget self, char const * source_regex, SBFileSpecList module_list, SBFileSpecList source_file, SBStringList func_names) -> SBBreakpoint\n"
		""},
	 { "SBTarget_BreakpointCreateForException", _wrap_SBTarget_BreakpointCreateForException, METH_VARARGS, "SBTarget_BreakpointCreateForException(SBTarget self, lldb::LanguageType language, bool catch_bp, bool throw_bp) -> SBBreakpoint"},
	 { "SBTarget_BreakpointCreateByAddress", _wrap_SBTarget_BreakpointCreateByAddress, METH_VARARGS, "SBTarget_BreakpointCreateByAddress(SBTarget self, lldb::addr_t address) -> SBBreakpoint"},
	 { "SBTarget_BreakpointCreateBySBAddress", _wrap_SBTarget_BreakpointCreateBySBAddress, METH_VARARGS, "SBTarget_BreakpointCreateBySBAddress(SBTarget self, SBAddress address) -> SBBreakpoint"},
	 { "SBTarget_BreakpointCreateFromScript", _wrap_SBTarget_BreakpointCreateFromScript, METH_VARARGS, "\n"
		"SBTarget_BreakpointCreateFromScript(SBTarget self, char const * class_name, SBStructuredData extra_args, SBFileSpecList module_list, SBFileSpecList file_list, bool request_hardware=False) -> SBBreakpoint\n"
		"\n"
		"    Create a breakpoint using a scripted resolver.\n"
		"\n"
		"    @param[in] class_name\n"
		"       This is the name of the class that implements a scripted resolver.\n"
		"       The class should have the following signature: ::\n"
		"\n"
		"           class Resolver:\n"
		"               def __init__(self, bkpt, extra_args):\n"
		"                   # bkpt - the breakpoint for which this is the resolver.  When\n"
		"                   # the resolver finds an interesting address, call AddLocation\n"
		"                   # on this breakpoint to add it.\n"
		"                   #\n"
		"                   # extra_args - an SBStructuredData that can be used to\n"
		"                   # parametrize this instance.  Same as the extra_args passed\n"
		"                   # to BreakpointCreateFromScript.\n"
		"\n"
		"               def __get_depth__ (self):\n"
		"                   # This is optional, but if defined, you should return the\n"
		"                   # depth at which you want the callback to be called.  The\n"
		"                   # available options are:\n"
		"                   #    lldb.eSearchDepthModule\n"
		"                   #    lldb.eSearchDepthCompUnit\n"
		"                   # The default if you don't implement this method is\n"
		"                   # eSearchDepthModule.\n"
		"\n"
		"               def __callback__(self, sym_ctx):\n"
		"                   # sym_ctx - an SBSymbolContext that is the cursor in the\n"
		"                   # search through the program to resolve breakpoints.\n"
		"                   # The sym_ctx will be filled out to the depth requested in\n"
		"                   # __get_depth__.\n"
		"                   # Look in this sym_ctx for new breakpoint locations,\n"
		"                   # and if found use bkpt.AddLocation to add them.\n"
		"                   # Note, you will only get called for modules/compile_units that\n"
		"                   # pass the SearchFilter provided by the module_list & file_list\n"
		"                   # passed into BreakpointCreateFromScript.\n"
		"\n"
		"               def get_short_help(self):\n"
		"                   # Optional, but if implemented return a short string that will\n"
		"                   # be printed at the beginning of the break list output for the\n"
		"                   # breakpoint.\n"
		"\n"
		"    @param[in] extra_args\n"
		"       This is an SBStructuredData object that will get passed to the\n"
		"       constructor of the class in class_name.  You can use this to\n"
		"       reuse the same class, parametrizing it with entries from this\n"
		"       dictionary.\n"
		"\n"
		"    @param module_list\n"
		"       If this is non-empty, this will be used as the module filter in the\n"
		"       SearchFilter created for this breakpoint.\n"
		"\n"
		"    @param file_list\n"
		"       If this is non-empty, this will be used as the comp unit filter in the\n"
		"       SearchFilter created for this breakpoint.\n"
		"\n"
		"    @return\n"
		"        An SBBreakpoint that will set locations based on the logic in the\n"
		"        resolver's search callback.\n"
		""},
	 { "SBTarget_BreakpointsCreateFromFile", _wrap_SBTarget_BreakpointsCreateFromFile, METH_VARARGS, "\n"
		"SBTarget_BreakpointsCreateFromFile(SBTarget self, SBFileSpec source_file, SBBreakpointList new_bps) -> SBError\n"
		"SBTarget_BreakpointsCreateFromFile(SBTarget self, SBFileSpec source_file, SBStringList matching_names, SBBreakpointList new_bps) -> SBError\n"
		"\n"
		"    Read breakpoints from source_file and return the newly created\n"
		"    breakpoints in bkpt_list.\n"
		"\n"
		"    @param[in] source_file\n"
		"       The file from which to read the breakpoints\n"
		"\n"
		"    @param[in] matching_names\n"
		"       Only read in breakpoints whose names match one of the names in this\n"
		"       list.\n"
		"\n"
		"    @param[out] bkpt_list\n"
		"       A list of the newly created breakpoints.\n"
		"\n"
		"    @return\n"
		"        An SBError detailing any errors in reading in the breakpoints.\n"
		""},
	 { "SBTarget_BreakpointsWriteToFile", _wrap_SBTarget_BreakpointsWriteToFile, METH_VARARGS, "\n"
		"SBTarget_BreakpointsWriteToFile(SBTarget self, SBFileSpec dest_file) -> SBError\n"
		"SBTarget_BreakpointsWriteToFile(SBTarget self, SBFileSpec dest_file, SBBreakpointList bkpt_list, bool append=False) -> SBError\n"
		"\n"
		"    Write breakpoints listed in bkpt_list to dest_file.\n"
		"\n"
		"    @param[in] dest_file\n"
		"       The file to which to write the breakpoints.\n"
		"\n"
		"    @param[in] bkpt_list\n"
		"       Only write breakpoints from this list.\n"
		"\n"
		"    @param[in] append\n"
		"       If true, append the breakpoints in bkpt_list to the others\n"
		"       serialized in dest_file.  If dest_file doesn't exist, then a new\n"
		"       file will be created and the breakpoints in bkpt_list written to it.\n"
		"\n"
		"    @return\n"
		"        An SBError detailing any errors in writing in the breakpoints.\n"
		""},
	 { "SBTarget_GetNumBreakpoints", _wrap_SBTarget_GetNumBreakpoints, METH_O, "SBTarget_GetNumBreakpoints(SBTarget self) -> uint32_t"},
	 { "SBTarget_GetBreakpointAtIndex", _wrap_SBTarget_GetBreakpointAtIndex, METH_VARARGS, "SBTarget_GetBreakpointAtIndex(SBTarget self, uint32_t idx) -> SBBreakpoint"},
	 { "SBTarget_BreakpointDelete", _wrap_SBTarget_BreakpointDelete, METH_VARARGS, "SBTarget_BreakpointDelete(SBTarget self, lldb::break_id_t break_id) -> bool"},
	 { "SBTarget_FindBreakpointByID", _wrap_SBTarget_FindBreakpointByID, METH_VARARGS, "SBTarget_FindBreakpointByID(SBTarget self, lldb::break_id_t break_id) -> SBBreakpoint"},
	 { "SBTarget_FindBreakpointsByName", _wrap_SBTarget_FindBreakpointsByName, METH_VARARGS, "SBTarget_FindBreakpointsByName(SBTarget self, char const * name, SBBreakpointList bkpt_list) -> bool"},
	 { "SBTarget_GetBreakpointNames", _wrap_SBTarget_GetBreakpointNames, METH_VARARGS, "SBTarget_GetBreakpointNames(SBTarget self, SBStringList names)"},
	 { "SBTarget_DeleteBreakpointName", _wrap_SBTarget_DeleteBreakpointName, METH_VARARGS, "SBTarget_DeleteBreakpointName(SBTarget self, char const * name)"},
	 { "SBTarget_EnableAllBreakpoints", _wrap_SBTarget_EnableAllBreakpoints, METH_O, "SBTarget_EnableAllBreakpoints(SBTarget self) -> bool"},
	 { "SBTarget_DisableAllBreakpoints", _wrap_SBTarget_DisableAllBreakpoints, METH_O, "SBTarget_DisableAllBreakpoints(SBTarget self) -> bool"},
	 { "SBTarget_DeleteAllBreakpoints", _wrap_SBTarget_DeleteAllBreakpoints, METH_O, "SBTarget_DeleteAllBreakpoints(SBTarget self) -> bool"},
	 { "SBTarget_GetNumWatchpoints", _wrap_SBTarget_GetNumWatchpoints, METH_O, "SBTarget_GetNumWatchpoints(SBTarget self) -> uint32_t"},
	 { "SBTarget_GetWatchpointAtIndex", _wrap_SBTarget_GetWatchpointAtIndex, METH_VARARGS, "SBTarget_GetWatchpointAtIndex(SBTarget self, uint32_t idx) -> SBWatchpoint"},
	 { "SBTarget_DeleteWatchpoint", _wrap_SBTarget_DeleteWatchpoint, METH_VARARGS, "SBTarget_DeleteWatchpoint(SBTarget self, lldb::watch_id_t watch_id) -> bool"},
	 { "SBTarget_FindWatchpointByID", _wrap_SBTarget_FindWatchpointByID, METH_VARARGS, "SBTarget_FindWatchpointByID(SBTarget self, lldb::watch_id_t watch_id) -> SBWatchpoint"},
	 { "SBTarget_WatchAddress", _wrap_SBTarget_WatchAddress, METH_VARARGS, "SBTarget_WatchAddress(SBTarget self, lldb::addr_t addr, size_t size, bool read, bool modify, SBError error) -> SBWatchpoint"},
	 { "SBTarget_WatchpointCreateByAddress", _wrap_SBTarget_WatchpointCreateByAddress, METH_VARARGS, "SBTarget_WatchpointCreateByAddress(SBTarget self, lldb::addr_t addr, size_t size, SBWatchpointOptions options, SBError error) -> SBWatchpoint"},
	 { "SBTarget_EnableAllWatchpoints", _wrap_SBTarget_EnableAllWatchpoints, METH_O, "SBTarget_EnableAllWatchpoints(SBTarget self) -> bool"},
	 { "SBTarget_DisableAllWatchpoints", _wrap_SBTarget_DisableAllWatchpoints, METH_O, "SBTarget_DisableAllWatchpoints(SBTarget self) -> bool"},
	 { "SBTarget_DeleteAllWatchpoints", _wrap_SBTarget_DeleteAllWatchpoints, METH_O, "SBTarget_DeleteAllWatchpoints(SBTarget self) -> bool"},
	 { "SBTarget_GetBroadcaster", _wrap_SBTarget_GetBroadcaster, METH_O, "SBTarget_GetBroadcaster(SBTarget self) -> SBBroadcaster"},
	 { "SBTarget_FindFirstType", _wrap_SBTarget_FindFirstType, METH_VARARGS, "SBTarget_FindFirstType(SBTarget self, char const * type) -> SBType"},
	 { "SBTarget_FindTypes", _wrap_SBTarget_FindTypes, METH_VARARGS, "SBTarget_FindTypes(SBTarget self, char const * type) -> SBTypeList"},
	 { "SBTarget_GetBasicType", _wrap_SBTarget_GetBasicType, METH_VARARGS, "SBTarget_GetBasicType(SBTarget self, lldb::BasicType type) -> SBType"},
	 { "SBTarget_CreateValueFromAddress", _wrap_SBTarget_CreateValueFromAddress, METH_VARARGS, "\n"
		"SBTarget_CreateValueFromAddress(SBTarget self, char const * name, SBAddress addr, SBType type) -> SBValue\n"
		"\n"
		"    Create an SBValue with the given name by treating the memory starting at addr as an entity of type.\n"
		"\n"
		"    @param[in] name\n"
		"        The name of the resultant SBValue\n"
		"\n"
		"    @param[in] addr\n"
		"        The address of the start of the memory region to be used.\n"
		"\n"
		"    @param[in] type\n"
		"        The type to use to interpret the memory starting at addr.\n"
		"\n"
		"    @return\n"
		"        An SBValue of the given type, may be invalid if there was an error reading\n"
		"        the underlying memory.\n"
		""},
	 { "SBTarget_CreateValueFromData", _wrap_SBTarget_CreateValueFromData, METH_VARARGS, "SBTarget_CreateValueFromData(SBTarget self, char const * name, SBData data, SBType type) -> SBValue"},
	 { "SBTarget_CreateValueFromExpression", _wrap_SBTarget_CreateValueFromExpression, METH_VARARGS, "SBTarget_CreateValueFromExpression(SBTarget self, char const * name, char const * expr) -> SBValue"},
	 { "SBTarget_GetSourceManager", _wrap_SBTarget_GetSourceManager, METH_O, "SBTarget_GetSourceManager(SBTarget self) -> SBSourceManager"},
	 { "SBTarget_ReadInstructions", _wrap_SBTarget_ReadInstructions, METH_VARARGS, "\n"
		"SBTarget_ReadInstructions(SBTarget self, SBAddress base_addr, uint32_t count) -> SBInstructionList\n"
		"SBTarget_ReadInstructions(SBTarget self, SBAddress base_addr, uint32_t count, char const * flavor_string) -> SBInstructionList\n"
		"SBTarget_ReadInstructions(SBTarget self, SBAddress start_addr, SBAddress end_addr, char const * flavor_string) -> SBInstructionList\n"
		"\n"
		"    Disassemble a specified number of instructions starting at an address.\n"
		"\n"
		"    :param base_addr: the address to start disassembly from.\n"
		"    :param count: the number of instructions to disassemble.\n"
		"    :param flavor_string: may be 'intel' or 'att' on x86 targets to specify that style of disassembly.\n"
		"    :rtype: SBInstructionList\n"
		"\n"
		""},
	 { "SBTarget_GetInstructions", _wrap_SBTarget_GetInstructions, METH_VARARGS, "\n"
		"SBTarget_GetInstructions(SBTarget self, SBAddress base_addr, void const * buf) -> SBInstructionList\n"
		"\n"
		"    Disassemble the bytes in a buffer and return them in an SBInstructionList.\n"
		"\n"
		"    :param base_addr: used for symbolicating the offsets in the byte stream when disassembling.\n"
		"    :param buf: bytes to be disassembled.\n"
		"    :param size: (C++) size of the buffer.\n"
		"    :rtype: SBInstructionList\n"
		"\n"
		""},
	 { "SBTarget_GetInstructionsWithFlavor", _wrap_SBTarget_GetInstructionsWithFlavor, METH_VARARGS, "\n"
		"SBTarget_GetInstructionsWithFlavor(SBTarget self, SBAddress base_addr, char const * flavor_string, void const * buf) -> SBInstructionList\n"
		"\n"
		"    Disassemble the bytes in a buffer and return them in an SBInstructionList, with a supplied flavor.\n"
		"\n"
		"    :param base_addr: used for symbolicating the offsets in the byte stream when disassembling.\n"
		"    :param flavor:  may be 'intel' or 'att' on x86 targets to specify that style of disassembly.\n"
		"    :param buf: bytes to be disassembled.\n"
		"    :param size: (C++) size of the buffer.\n"
		"    :rtype: SBInstructionList\n"
		"\n"
		""},
	 { "SBTarget_FindSymbols", _wrap_SBTarget_FindSymbols, METH_VARARGS, "SBTarget_FindSymbols(SBTarget self, char const * name, lldb::SymbolType type=eSymbolTypeAny) -> SBSymbolContextList"},
	 { "SBTarget___eq__", _wrap_SBTarget___eq__, METH_VARARGS, "SBTarget___eq__(SBTarget self, SBTarget rhs) -> bool"},
	 { "SBTarget___ne__", _wrap_SBTarget___ne__, METH_VARARGS, "SBTarget___ne__(SBTarget self, SBTarget rhs) -> bool"},
	 { "SBTarget_GetDescription", _wrap_SBTarget_GetDescription, METH_VARARGS, "SBTarget_GetDescription(SBTarget self, SBStream description, lldb::DescriptionLevel description_level) -> bool"},
	 { "SBTarget_EvaluateExpression", _wrap_SBTarget_EvaluateExpression, METH_VARARGS, "\n"
		"SBTarget_EvaluateExpression(SBTarget self, char const * expr) -> SBValue\n"
		"SBTarget_EvaluateExpression(SBTarget self, char const * expr, SBExpressionOptions options) -> SBValue\n"
		""},
	 { "SBTarget_GetStackRedZoneSize", _wrap_SBTarget_GetStackRedZoneSize, METH_O, "SBTarget_GetStackRedZoneSize(SBTarget self) -> lldb::addr_t"},
	 { "SBTarget_IsLoaded", _wrap_SBTarget_IsLoaded, METH_VARARGS, "\n"
		"SBTarget_IsLoaded(SBTarget self, SBModule module) -> bool\n"
		"\n"
		"    Returns true if the module has been loaded in this `SBTarget`.\n"
		"    A module can be loaded either by the dynamic loader or by being manually\n"
		"    added to the target (see `SBTarget.AddModule` and the ``target module add`` command).\n"
		"\n"
		"    :rtype: bool\n"
		"\n"
		""},
	 { "SBTarget_GetLaunchInfo", _wrap_SBTarget_GetLaunchInfo, METH_O, "SBTarget_GetLaunchInfo(SBTarget self) -> SBLaunchInfo"},
	 { "SBTarget_SetLaunchInfo", _wrap_SBTarget_SetLaunchInfo, METH_VARARGS, "SBTarget_SetLaunchInfo(SBTarget self, SBLaunchInfo launch_info)"},
	 { "SBTarget_GetTrace", _wrap_SBTarget_GetTrace, METH_O, "\n"
		"Get a *SBTrace* object the can manage the processor trace information of\n"
		"this target.\n"
		"\n"
		":rtype: :py:class:`SBTrace`\n"
		":return: \n"
		"      The trace object. The returned SBTrace object might not be valid, so it\n"
		"      should be checked with a call to \"bool SBTrace::IsValid()\".\n"
		""},
	 { "SBTarget_CreateTrace", _wrap_SBTarget_CreateTrace, METH_VARARGS, "\n"
		"Create a *Trace* object for the current target using the using the\n"
		"default supported tracing technology for this process.\n"
		"\n"
		":type error: :py:class:`SBError`, out\n"
		":param error:\n"
		"        An error if a Trace already exists or the trace couldn't be created.\n"
		""},
	 { "SBTarget_GetAPIMutex", _wrap_SBTarget_GetAPIMutex, METH_O, "SBTarget_GetAPIMutex(SBTarget self) -> SBMutex"},
	 { "SBTarget_RegisterScriptedFrameProvider", _wrap_SBTarget_RegisterScriptedFrameProvider, METH_VARARGS, "\n"
		"Register a scripted frame provider for this target.\n"
		"If a scripted frame provider with the same name and same argument\n"
		"dictionary is already registered on this target, it will be overwritten.\n"
		"\n"
		":type class_name: string, in\n"
		":param class_name:\n"
		"        The name of the Python class that implements the frame provider.\n"
		"\n"
		":type args_dict: :py:class:`SBStructuredData`, in\n"
		":param args_dict:\n"
		"        A dictionary of arguments to pass to the frame provider class.\n"
		"\n"
		":type error: :py:class:`SBError`, out\n"
		":param error:\n"
		"        An error object indicating success or failure.\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"        A unique identifier for the frame provider descriptor that was\n"
		"        registered. 0 if the registration failed.\n"
		""},
	 { "SBTarget_RemoveScriptedFrameProvider", _wrap_SBTarget_RemoveScriptedFrameProvider, METH_VARARGS, "\n"
		"Remove a scripted frame provider from this target by name.\n"
		"\n"
		":type provider_id: int, in\n"
		":param provider_id:\n"
		"        The id of the frame provider class to remove.\n"
		"\n"
		":rtype: :py:class:`SBError`\n"
		":return: \n"
		"        An error object indicating success or failure.\n"
		""},
	 { "SBTarget___repr__", _wrap_SBTarget___repr__, METH_O, "SBTarget___repr__(SBTarget self) -> std::string"},
	 { "SBTarget_swigregister", SBTarget_swigregister, METH_O, NULL},
	 { "SBTarget_swiginit", SBTarget_swiginit, METH_VARARGS, NULL},
	 { "SBThread_GetBroadcasterClassName", _wrap_SBThread_GetBroadcasterClassName, METH_NOARGS, "SBThread_GetBroadcasterClassName() -> char const *"},
	 { "new_SBThread", _wrap_new_SBThread, METH_VARARGS, "\n"
		"SBThread()\n"
		"new_SBThread(SBThread thread) -> SBThread\n"
		""},
	 { "delete_SBThread", _wrap_delete_SBThread, METH_O, "delete_SBThread(SBThread self)"},
	 { "SBThread_GetQueue", _wrap_SBThread_GetQueue, METH_O, "\n"
		"SBThread_GetQueue(SBThread self) -> SBQueue\n"
		"\n"
		"    Return the SBQueue for this thread.  If this thread is not currently associated\n"
		"    with a libdispatch queue, the SBQueue object's IsValid() method will return false.\n"
		"    If this SBThread is actually a HistoryThread, we may be able to provide QueueID\n"
		"    and QueueName, but not provide an SBQueue.  Those individual attributes may have\n"
		"    been saved for the HistoryThread without enough information to reconstitute the\n"
		"    entire SBQueue at that time.\n"
		"    This method takes no arguments, returns an SBQueue.\n"
		""},
	 { "SBThread___nonzero__", _wrap_SBThread___nonzero__, METH_O, "SBThread___nonzero__(SBThread self) -> bool"},
	 { "SBThread_IsValid", _wrap_SBThread_IsValid, METH_O, "SBThread_IsValid(SBThread self) -> bool"},
	 { "SBThread_Clear", _wrap_SBThread_Clear, METH_O, "SBThread_Clear(SBThread self)"},
	 { "SBThread_GetStopReason", _wrap_SBThread_GetStopReason, METH_O, "SBThread_GetStopReason(SBThread self) -> lldb::StopReason"},
	 { "SBThread_GetStopReasonDataCount", _wrap_SBThread_GetStopReasonDataCount, METH_O, "\n"
		"SBThread_GetStopReasonDataCount(SBThread self) -> size_t\n"
		"\n"
		"    Get the number of words associated with the stop reason.\n"
		"    See also GetStopReasonDataAtIndex().\n"
		""},
	 { "SBThread_GetStopReasonDataAtIndex", _wrap_SBThread_GetStopReasonDataAtIndex, METH_VARARGS, "\n"
		"SBThread_GetStopReasonDataAtIndex(SBThread self, uint32_t idx) -> uint64_t\n"
		"\n"
		"    Get information associated with a stop reason.\n"
		"\n"
		"    Breakpoint stop reasons will have data that consists of pairs of\n"
		"    breakpoint IDs followed by the breakpoint location IDs (they always come\n"
		"    in pairs).\n"
		"\n"
		"    Stop Reason              Count Data Type\n"
		"    ======================== ===== =========================================\n"
		"    eStopReasonNone          0\n"
		"    eStopReasonTrace         0\n"
		"    eStopReasonBreakpoint    N     duple: {breakpoint id, location id}\n"
		"    eStopReasonWatchpoint    1     watchpoint id\n"
		"    eStopReasonSignal        1     unix signal number\n"
		"    eStopReasonException     N     exception data\n"
		"    eStopReasonExec          0\n"
		"    eStopReasonFork          1     pid of the child process\n"
		"    eStopReasonVFork         1     pid of the child process\n"
		"    eStopReasonVForkDone     0\n"
		"    eStopReasonPlanComplete  0\n"
		""},
	 { "SBThread_GetStopReasonExtendedInfoAsJSON", _wrap_SBThread_GetStopReasonExtendedInfoAsJSON, METH_VARARGS, "\n"
		"SBThread_GetStopReasonExtendedInfoAsJSON(SBThread self, SBStream stream) -> bool\n"
		"\n"
		"    Collects a thread's stop reason extended information dictionary and prints it\n"
		"    into the SBStream in a JSON format. The format of this JSON dictionary depends\n"
		"    on the stop reason and is currently used only for instrumentation plugins.\n"
		""},
	 { "SBThread_GetStopReasonExtendedBacktraces", _wrap_SBThread_GetStopReasonExtendedBacktraces, METH_VARARGS, "\n"
		"SBThread_GetStopReasonExtendedBacktraces(SBThread self, lldb::InstrumentationRuntimeType type) -> SBThreadCollection\n"
		"\n"
		"    Returns a collection of historical stack traces that are significant to the\n"
		"    current stop reason. Used by ThreadSanitizer, where we provide various stack\n"
		"    traces that were involved in a data race or other type of detected issue.\n"
		""},
	 { "SBThread_GetStopDescription", _wrap_SBThread_GetStopDescription, METH_VARARGS, "\n"
		"SBThread_GetStopDescription(SBThread self, SBStream stream) -> bool\n"
		"SBThread_GetStopDescription(SBThread self, char * dst_or_null) -> size_t\n"
		"\n"
		"    Pass only an (int)length and expect to get a Python string describing the\n"
		"    stop reason.\n"
		""},
	 { "SBThread_GetStopReturnValue", _wrap_SBThread_GetStopReturnValue, METH_O, "SBThread_GetStopReturnValue(SBThread self) -> SBValue"},
	 { "SBThread_GetThreadID", _wrap_SBThread_GetThreadID, METH_O, "\n"
		"SBThread_GetThreadID(SBThread self) -> lldb::tid_t\n"
		"\n"
		"    Returns a unique thread identifier (type lldb::tid_t, typically a 64-bit type)\n"
		"    for the current SBThread that will remain constant throughout the thread's\n"
		"    lifetime in this process and will not be reused by another thread during this\n"
		"    process lifetime.  On Mac OS X systems, this is a system-wide unique thread\n"
		"    identifier; this identifier is also used by other tools like sample which helps\n"
		"    to associate data from those tools with lldb.  See related GetIndexID.\n"
		""},
	 { "SBThread_GetIndexID", _wrap_SBThread_GetIndexID, METH_O, "\n"
		"SBThread_GetIndexID(SBThread self) -> uint32_t\n"
		"\n"
		"    Return the index number for this SBThread.  The index number is the same thing\n"
		"    that a user gives as an argument to 'thread select' in the command line lldb.\n"
		"    These numbers start at 1 (for the first thread lldb sees in a debug session)\n"
		"    and increments up throughout the process lifetime.  An index number will not be\n"
		"    reused for a different thread later in a process - thread 1 will always be\n"
		"    associated with the same thread.  See related GetThreadID.\n"
		"    This method returns a uint32_t index number, takes no arguments.\n"
		""},
	 { "SBThread_GetName", _wrap_SBThread_GetName, METH_O, "SBThread_GetName(SBThread self) -> char const *"},
	 { "SBThread_GetQueueName", _wrap_SBThread_GetQueueName, METH_O, "\n"
		"SBThread_GetQueueName(SBThread self) -> char const *\n"
		"\n"
		"    Return the queue name associated with this thread, if any, as a str.\n"
		"    For example, with a libdispatch (aka Grand Central Dispatch) queue.\n"
		""},
	 { "SBThread_GetQueueID", _wrap_SBThread_GetQueueID, METH_O, "\n"
		"SBThread_GetQueueID(SBThread self) -> lldb::queue_id_t\n"
		"\n"
		"    Return the dispatch_queue_id for this thread, if any, as a lldb::queue_id_t.\n"
		"    For example, with a libdispatch (aka Grand Central Dispatch) queue.\n"
		""},
	 { "SBThread_GetInfoItemByPathAsString", _wrap_SBThread_GetInfoItemByPathAsString, METH_VARARGS, "\n"
		"SBThread_GetInfoItemByPathAsString(SBThread self, char const * path, SBStream strm) -> bool\n"
		"\n"
		"    Takes a path string and a SBStream reference as parameters, returns a bool.\n"
		"    Collects the thread's 'info' dictionary from the remote system, uses the path\n"
		"    argument to descend into the dictionary to an item of interest, and prints\n"
		"    it into the SBStream in a natural format.  Return bool is to indicate if\n"
		"    anything was printed into the stream (true) or not (false).\n"
		""},
	 { "SBThread_StepOver", _wrap_SBThread_StepOver, METH_VARARGS, "\n"
		"SBThread_StepOver(SBThread self, lldb::RunMode stop_other_threads=eOnlyDuringStepping)\n"
		"SBThread_StepOver(SBThread self, lldb::RunMode stop_other_threads, SBError error)\n"
		"Do a source level single step over in the currently selected thread.\n"
		""},
	 { "SBThread_StepInto", _wrap_SBThread_StepInto, METH_VARARGS, "\n"
		"SBThread_StepInto(SBThread self, lldb::RunMode stop_other_threads=eOnlyDuringStepping)\n"
		"SBThread_StepInto(SBThread self, char const * target_name, lldb::RunMode stop_other_threads=eOnlyDuringStepping)\n"
		"SBThread_StepInto(SBThread self, char const * target_name, uint32_t end_line, SBError error, lldb::RunMode stop_other_threads=eOnlyDuringStepping)\n"
		"\n"
		"    Step the current thread from the current source line to the line given by end_line, stopping if\n"
		"    the thread steps into the function given by target_name.  If target_name is None, then stepping will stop\n"
		"    in any of the places we would normally stop.\n"
		""},
	 { "SBThread_StepOut", _wrap_SBThread_StepOut, METH_VARARGS, "\n"
		"SBThread_StepOut(SBThread self)\n"
		"SBThread_StepOut(SBThread self, SBError error)\n"
		"Step out of the currently selected thread.\n"
		""},
	 { "SBThread_StepOutOfFrame", _wrap_SBThread_StepOutOfFrame, METH_VARARGS, "\n"
		"SBThread_StepOutOfFrame(SBThread self, SBFrame frame)\n"
		"SBThread_StepOutOfFrame(SBThread self, SBFrame frame, SBError error)\n"
		"Step out of the specified frame.\n"
		""},
	 { "SBThread_StepInstruction", _wrap_SBThread_StepInstruction, METH_VARARGS, "\n"
		"SBThread_StepInstruction(SBThread self, bool step_over)\n"
		"SBThread_StepInstruction(SBThread self, bool step_over, SBError error)\n"
		"Do an instruction level single step in the currently selected thread.\n"
		""},
	 { "SBThread_StepOverUntil", _wrap_SBThread_StepOverUntil, METH_VARARGS, "SBThread_StepOverUntil(SBThread self, SBFrame frame, SBFileSpec file_spec, uint32_t line) -> SBError"},
	 { "SBThread_StepUsingScriptedThreadPlan", _wrap_SBThread_StepUsingScriptedThreadPlan, METH_VARARGS, "\n"
		"SBThread_StepUsingScriptedThreadPlan(SBThread self, char const * script_class_name) -> SBError\n"
		"SBThread_StepUsingScriptedThreadPlan(SBThread self, char const * script_class_name, bool resume_immediately) -> SBError\n"
		"SBThread_StepUsingScriptedThreadPlan(SBThread self, char const * script_class_name, SBStructuredData args_data, bool resume_immediately) -> SBError\n"
		""},
	 { "SBThread_JumpToLine", _wrap_SBThread_JumpToLine, METH_VARARGS, "SBThread_JumpToLine(SBThread self, SBFileSpec file_spec, uint32_t line) -> SBError"},
	 { "SBThread_RunToAddress", _wrap_SBThread_RunToAddress, METH_VARARGS, "\n"
		"SBThread_RunToAddress(SBThread self, lldb::addr_t addr)\n"
		"SBThread_RunToAddress(SBThread self, lldb::addr_t addr, SBError error)\n"
		""},
	 { "SBThread_ReturnFromFrame", _wrap_SBThread_ReturnFromFrame, METH_VARARGS, "\n"
		"SBThread_ReturnFromFrame(SBThread self, SBFrame frame, SBValue return_value) -> SBError\n"
		"\n"
		"    Force a return from the frame passed in (and any frames younger than it)\n"
		"    without executing any more code in those frames.  If return_value contains\n"
		"    a valid SBValue, that will be set as the return value from frame.  Note, at\n"
		"    present only scalar return values are supported.\n"
		""},
	 { "SBThread_UnwindInnermostExpression", _wrap_SBThread_UnwindInnermostExpression, METH_O, "\n"
		"SBThread_UnwindInnermostExpression(SBThread self) -> SBError\n"
		"\n"
		"    Unwind the stack frames from the innermost expression evaluation.\n"
		"    This API is equivalent to 'thread return -x'.\n"
		""},
	 { "SBThread_Suspend", _wrap_SBThread_Suspend, METH_VARARGS, "\n"
		"SBThread_Suspend(SBThread self) -> bool\n"
		"SBThread_Suspend(SBThread self, SBError error) -> bool\n"
		"\n"
		"    LLDB currently supports process centric debugging which means when any\n"
		"    thread in a process stops, all other threads are stopped. The Suspend()\n"
		"    call here tells our process to suspend a thread and not let it run when\n"
		"    the other threads in a process are allowed to run. So when\n"
		"    SBProcess::Continue() is called, any threads that aren't suspended will\n"
		"    be allowed to run. If any of the SBThread functions for stepping are\n"
		"    called (StepOver, StepInto, StepOut, StepInstruction, RunToAddres), the\n"
		"    thread will now be allowed to run and these functions will simply return.\n"
		"\n"
		"    Eventually we plan to add support for thread centric debugging where\n"
		"    each thread is controlled individually and each thread would broadcast\n"
		"    its state, but we haven't implemented this yet.\n"
		"\n"
		"    Likewise the SBThread::Resume() call will again allow the thread to run\n"
		"    when the process is continued.\n"
		"\n"
		"    Suspend() and Resume() functions are not currently reference counted, if\n"
		"    anyone has the need for them to be reference counted, please let us\n"
		"    know.\n"
		""},
	 { "SBThread_Resume", _wrap_SBThread_Resume, METH_VARARGS, "\n"
		"SBThread_Resume(SBThread self) -> bool\n"
		"SBThread_Resume(SBThread self, SBError error) -> bool\n"
		""},
	 { "SBThread_IsSuspended", _wrap_SBThread_IsSuspended, METH_O, "SBThread_IsSuspended(SBThread self) -> bool"},
	 { "SBThread_IsStopped", _wrap_SBThread_IsStopped, METH_O, "SBThread_IsStopped(SBThread self) -> bool"},
	 { "SBThread_GetNumFrames", _wrap_SBThread_GetNumFrames, METH_O, "SBThread_GetNumFrames(SBThread self) -> uint32_t"},
	 { "SBThread_GetFrameAtIndex", _wrap_SBThread_GetFrameAtIndex, METH_VARARGS, "SBThread_GetFrameAtIndex(SBThread self, uint32_t idx) -> SBFrame"},
	 { "SBThread_GetFrames", _wrap_SBThread_GetFrames, METH_O, "SBThread_GetFrames(SBThread self) -> SBFrameList"},
	 { "SBThread_GetSelectedFrame", _wrap_SBThread_GetSelectedFrame, METH_O, "SBThread_GetSelectedFrame(SBThread self) -> SBFrame"},
	 { "SBThread_SetSelectedFrame", _wrap_SBThread_SetSelectedFrame, METH_VARARGS, "SBThread_SetSelectedFrame(SBThread self, uint32_t frame_idx) -> SBFrame"},
	 { "SBThread_EventIsThreadEvent", _wrap_SBThread_EventIsThreadEvent, METH_O, "SBThread_EventIsThreadEvent(SBEvent event) -> bool"},
	 { "SBThread_GetStackFrameFromEvent", _wrap_SBThread_GetStackFrameFromEvent, METH_O, "SBThread_GetStackFrameFromEvent(SBEvent event) -> SBFrame"},
	 { "SBThread_GetThreadFromEvent", _wrap_SBThread_GetThreadFromEvent, METH_O, "SBThread_GetThreadFromEvent(SBEvent event) -> SBThread"},
	 { "SBThread_GetProcess", _wrap_SBThread_GetProcess, METH_O, "SBThread_GetProcess(SBThread self) -> SBProcess"},
	 { "SBThread___eq__", _wrap_SBThread___eq__, METH_VARARGS, "SBThread___eq__(SBThread self, SBThread rhs) -> bool"},
	 { "SBThread___ne__", _wrap_SBThread___ne__, METH_VARARGS, "SBThread___ne__(SBThread self, SBThread rhs) -> bool"},
	 { "SBThread_GetDescription", _wrap_SBThread_GetDescription, METH_VARARGS, "\n"
		"SBThread_GetDescription(SBThread self, SBStream description) -> bool\n"
		"SBThread_GetDescription(SBThread self, SBStream description, bool stop_format) -> bool\n"
		"\n"
		"    Get the description strings for this thread that match what the\n"
		"    lldb driver will present, using the thread-format (stop_format==false)\n"
		"    or thread-stop-format (stop_format = true).\n"
		""},
	 { "SBThread_GetDescriptionWithFormat", _wrap_SBThread_GetDescriptionWithFormat, METH_VARARGS, "\n"
		"Similar to *GetDescription()* but the format of the description can be\n"
		"configured via the ``format`` parameter. See\n"
		"https://lldb.llvm.org/use/formatting.html for more information on format\n"
		"strings.\n"
		"\n"
		":type format: :py:class:`SBFormat`, in\n"
		":param format:\n"
		"      The format to use for generating the description.\n"
		"\n"
		":type output: :py:class:`SBStream`, out\n"
		":param output:\n"
		"      The stream where the description will be written to.\n"
		"\n"
		":rtype: :py:class:`SBError`\n"
		":return: \n"
		"      An error object with an error message in case of failures.\n"
		""},
	 { "SBThread_GetStatus", _wrap_SBThread_GetStatus, METH_VARARGS, "SBThread_GetStatus(SBThread self, SBStream status) -> bool"},
	 { "SBThread_GetExtendedBacktraceThread", _wrap_SBThread_GetExtendedBacktraceThread, METH_VARARGS, "\n"
		"SBThread_GetExtendedBacktraceThread(SBThread self, char const * type) -> SBThread\n"
		"\n"
		"    Given an argument of str to specify the type of thread-origin extended\n"
		"    backtrace to retrieve, query whether the origin of this thread is\n"
		"    available.  An SBThread is retured; SBThread.IsValid will return true\n"
		"    if an extended backtrace was available.  The returned SBThread is not\n"
		"    a part of the SBProcess' thread list and it cannot be manipulated like\n"
		"    normal threads -- you cannot step or resume it, for instance -- it is\n"
		"    intended to used primarily for generating a backtrace.  You may request\n"
		"    the returned thread's own thread origin in turn.\n"
		""},
	 { "SBThread_GetExtendedBacktraceOriginatingIndexID", _wrap_SBThread_GetExtendedBacktraceOriginatingIndexID, METH_O, "\n"
		"SBThread_GetExtendedBacktraceOriginatingIndexID(SBThread self) -> uint32_t\n"
		"\n"
		"    If this SBThread is an ExtendedBacktrace thread, get the IndexID of the\n"
		"    original thread that this ExtendedBacktrace thread represents, if\n"
		"    available.  The thread that was running this backtrace in the past may\n"
		"    not have been registered with lldb's thread index (if it was created,\n"
		"    did its work, and was destroyed without lldb ever stopping execution).\n"
		"    In that case, this ExtendedBacktrace thread's IndexID will be returned.\n"
		""},
	 { "SBThread_GetCurrentException", _wrap_SBThread_GetCurrentException, METH_O, "\n"
		"SBThread_GetCurrentException(SBThread self) -> SBValue\n"
		"\n"
		"    Returns an SBValue object represeting the current exception for the thread,\n"
		"    if there is any. Currently, this works for Obj-C code and returns an SBValue\n"
		"    representing the NSException object at the throw site or that's currently\n"
		"    being processes.\n"
		""},
	 { "SBThread_GetCurrentExceptionBacktrace", _wrap_SBThread_GetCurrentExceptionBacktrace, METH_O, "\n"
		"SBThread_GetCurrentExceptionBacktrace(SBThread self) -> SBThread\n"
		"\n"
		"    Returns a historical (fake) SBThread representing the stack trace of an\n"
		"    exception, if there is one for the thread. Currently, this works for Obj-C\n"
		"    code, and can retrieve the throw-site backtrace of an NSException object\n"
		"    even when the program is no longer at the throw site.\n"
		""},
	 { "SBThread_SafeToCallFunctions", _wrap_SBThread_SafeToCallFunctions, METH_O, "\n"
		"SBThread_SafeToCallFunctions(SBThread self) -> bool\n"
		"\n"
		"    lldb may be able to detect that function calls should not be executed\n"
		"    on a given thread at a particular point in time.  It is recommended that\n"
		"    this is checked before performing an inferior function call on a given\n"
		"    thread.\n"
		""},
	 { "SBThread_GetSiginfo", _wrap_SBThread_GetSiginfo, METH_O, "\n"
		"SBThread_GetSiginfo(SBThread self) -> SBValue\n"
		"\n"
		"    Returns a SBValue object representing the siginfo for the current signal.\n"
		"\n"
		""},
	 { "SBThread___repr__", _wrap_SBThread___repr__, METH_O, "SBThread___repr__(SBThread self) -> std::string"},
	 { "SBThread_swigregister", SBThread_swigregister, METH_O, NULL},
	 { "SBThread_swiginit", SBThread_swiginit, METH_VARARGS, NULL},
	 { "new_SBThreadCollection", _wrap_new_SBThreadCollection, METH_VARARGS, "\n"
		"SBThreadCollection()\n"
		"new_SBThreadCollection(SBThreadCollection rhs) -> SBThreadCollection\n"
		""},
	 { "delete_SBThreadCollection", _wrap_delete_SBThreadCollection, METH_O, "delete_SBThreadCollection(SBThreadCollection self)"},
	 { "SBThreadCollection___nonzero__", _wrap_SBThreadCollection___nonzero__, METH_O, "SBThreadCollection___nonzero__(SBThreadCollection self) -> bool"},
	 { "SBThreadCollection_IsValid", _wrap_SBThreadCollection_IsValid, METH_O, "SBThreadCollection_IsValid(SBThreadCollection self) -> bool"},
	 { "SBThreadCollection_GetSize", _wrap_SBThreadCollection_GetSize, METH_O, "SBThreadCollection_GetSize(SBThreadCollection self) -> size_t"},
	 { "SBThreadCollection_GetThreadAtIndex", _wrap_SBThreadCollection_GetThreadAtIndex, METH_VARARGS, "SBThreadCollection_GetThreadAtIndex(SBThreadCollection self, size_t idx) -> SBThread"},
	 { "SBThreadCollection_swigregister", SBThreadCollection_swigregister, METH_O, NULL},
	 { "SBThreadCollection_swiginit", SBThreadCollection_swiginit, METH_VARARGS, NULL},
	 { "new_SBThreadPlan", _wrap_new_SBThreadPlan, METH_VARARGS, "\n"
		"SBThreadPlan()\n"
		"SBThreadPlan(SBThreadPlan threadPlan)\n"
		"SBThreadPlan(SBThread thread, char const * class_name)\n"
		"new_SBThreadPlan(SBThread thread, char const * class_name, SBStructuredData args_data) -> SBThreadPlan\n"
		""},
	 { "delete_SBThreadPlan", _wrap_delete_SBThreadPlan, METH_O, "delete_SBThreadPlan(SBThreadPlan self)"},
	 { "SBThreadPlan___nonzero__", _wrap_SBThreadPlan___nonzero__, METH_O, "SBThreadPlan___nonzero__(SBThreadPlan self) -> bool"},
	 { "SBThreadPlan_Clear", _wrap_SBThreadPlan_Clear, METH_O, "SBThreadPlan_Clear(SBThreadPlan self)"},
	 { "SBThreadPlan_GetStopReason", _wrap_SBThreadPlan_GetStopReason, METH_O, "SBThreadPlan_GetStopReason(SBThreadPlan self) -> lldb::StopReason"},
	 { "SBThreadPlan_GetStopReasonDataCount", _wrap_SBThreadPlan_GetStopReasonDataCount, METH_O, "\n"
		"SBThreadPlan_GetStopReasonDataCount(SBThreadPlan self) -> size_t\n"
		"\n"
		"    Get the number of words associated with the stop reason.\n"
		"    See also GetStopReasonDataAtIndex().\n"
		""},
	 { "SBThreadPlan_GetStopReasonDataAtIndex", _wrap_SBThreadPlan_GetStopReasonDataAtIndex, METH_VARARGS, "\n"
		"SBThreadPlan_GetStopReasonDataAtIndex(SBThreadPlan self, uint32_t idx) -> uint64_t\n"
		"\n"
		"    Get information associated with a stop reason.\n"
		"\n"
		"    Breakpoint stop reasons will have data that consists of pairs of\n"
		"    breakpoint IDs followed by the breakpoint location IDs (they always come\n"
		"    in pairs).\n"
		"\n"
		"    Stop Reason              Count Data Type\n"
		"    ======================== ===== =========================================\n"
		"    eStopReasonNone          0\n"
		"    eStopReasonTrace         0\n"
		"    eStopReasonBreakpoint    N     duple: {breakpoint id, location id}\n"
		"    eStopReasonWatchpoint    1     watchpoint id\n"
		"    eStopReasonSignal        1     unix signal number\n"
		"    eStopReasonException     N     exception data\n"
		"    eStopReasonExec          0\n"
		"    eStopReasonFork          1     pid of the child process\n"
		"    eStopReasonVFork         1     pid of the child process\n"
		"    eStopReasonVForkDone     0\n"
		"    eStopReasonPlanComplete  0\n"
		""},
	 { "SBThreadPlan_GetThread", _wrap_SBThreadPlan_GetThread, METH_O, "SBThreadPlan_GetThread(SBThreadPlan self) -> SBThread"},
	 { "SBThreadPlan_GetDescription", _wrap_SBThreadPlan_GetDescription, METH_VARARGS, "SBThreadPlan_GetDescription(SBThreadPlan self, SBStream description) -> bool"},
	 { "SBThreadPlan_SetPlanComplete", _wrap_SBThreadPlan_SetPlanComplete, METH_VARARGS, "SBThreadPlan_SetPlanComplete(SBThreadPlan self, bool success)"},
	 { "SBThreadPlan_IsPlanComplete", _wrap_SBThreadPlan_IsPlanComplete, METH_O, "SBThreadPlan_IsPlanComplete(SBThreadPlan self) -> bool"},
	 { "SBThreadPlan_IsPlanStale", _wrap_SBThreadPlan_IsPlanStale, METH_O, "SBThreadPlan_IsPlanStale(SBThreadPlan self) -> bool"},
	 { "SBThreadPlan_IsValid", _wrap_SBThreadPlan_IsValid, METH_VARARGS, "\n"
		"SBThreadPlan_IsValid(SBThreadPlan self) -> bool\n"
		"SBThreadPlan_IsValid(SBThreadPlan self) -> bool\n"
		""},
	 { "SBThreadPlan_GetStopOthers", _wrap_SBThreadPlan_GetStopOthers, METH_O, "\n"
		"SBThreadPlan_GetStopOthers(SBThreadPlan self) -> bool\n"
		"Return whether this plan will ask to stop other threads when it runs.\n"
		""},
	 { "SBThreadPlan_SetStopOthers", _wrap_SBThreadPlan_SetStopOthers, METH_VARARGS, "\n"
		"SBThreadPlan_SetStopOthers(SBThreadPlan self, bool stop_others)\n"
		"Set whether this plan will ask to stop other threads when it runs.\n"
		""},
	 { "SBThreadPlan_QueueThreadPlanForStepOverRange", _wrap_SBThreadPlan_QueueThreadPlanForStepOverRange, METH_VARARGS, "\n"
		"SBThreadPlan_QueueThreadPlanForStepOverRange(SBThreadPlan self, SBAddress start_address, lldb::addr_t range_size) -> SBThreadPlan\n"
		"SBThreadPlan_QueueThreadPlanForStepOverRange(SBThreadPlan self, SBAddress start_address, lldb::addr_t range_size, SBError error) -> SBThreadPlan\n"
		""},
	 { "SBThreadPlan_QueueThreadPlanForStepInRange", _wrap_SBThreadPlan_QueueThreadPlanForStepInRange, METH_VARARGS, "\n"
		"SBThreadPlan_QueueThreadPlanForStepInRange(SBThreadPlan self, SBAddress start_address, lldb::addr_t range_size) -> SBThreadPlan\n"
		"SBThreadPlan_QueueThreadPlanForStepInRange(SBThreadPlan self, SBAddress start_address, lldb::addr_t range_size, SBError error) -> SBThreadPlan\n"
		""},
	 { "SBThreadPlan_QueueThreadPlanForStepOut", _wrap_SBThreadPlan_QueueThreadPlanForStepOut, METH_VARARGS, "\n"
		"SBThreadPlan_QueueThreadPlanForStepOut(SBThreadPlan self, uint32_t frame_idx_to_step_to, bool first_insn=False) -> SBThreadPlan\n"
		"SBThreadPlan_QueueThreadPlanForStepOut(SBThreadPlan self, uint32_t frame_idx_to_step_to, bool first_insn, SBError error) -> SBThreadPlan\n"
		""},
	 { "SBThreadPlan_QueueThreadPlanForStepSingleInstruction", _wrap_SBThreadPlan_QueueThreadPlanForStepSingleInstruction, METH_VARARGS, "SBThreadPlan_QueueThreadPlanForStepSingleInstruction(SBThreadPlan self, bool step_over, SBError error) -> SBThreadPlan"},
	 { "SBThreadPlan_QueueThreadPlanForRunToAddress", _wrap_SBThreadPlan_QueueThreadPlanForRunToAddress, METH_VARARGS, "\n"
		"SBThreadPlan_QueueThreadPlanForRunToAddress(SBThreadPlan self, SBAddress address) -> SBThreadPlan\n"
		"SBThreadPlan_QueueThreadPlanForRunToAddress(SBThreadPlan self, SBAddress address, SBError error) -> SBThreadPlan\n"
		""},
	 { "SBThreadPlan_QueueThreadPlanForStepScripted", _wrap_SBThreadPlan_QueueThreadPlanForStepScripted, METH_VARARGS, "\n"
		"SBThreadPlan_QueueThreadPlanForStepScripted(SBThreadPlan self, char const * script_class_name) -> SBThreadPlan\n"
		"SBThreadPlan_QueueThreadPlanForStepScripted(SBThreadPlan self, char const * script_class_name, SBError error) -> SBThreadPlan\n"
		"SBThreadPlan_QueueThreadPlanForStepScripted(SBThreadPlan self, char const * script_class_name, SBStructuredData args_data, SBError error) -> SBThreadPlan\n"
		""},
	 { "SBThreadPlan_swigregister", SBThreadPlan_swigregister, METH_O, NULL},
	 { "SBThreadPlan_swiginit", SBThreadPlan_swiginit, METH_VARARGS, NULL},
	 { "new_SBTrace", _wrap_new_SBTrace, METH_NOARGS, "Default constructor for an invalid Trace object."},
	 { "SBTrace_LoadTraceFromFile", _wrap_SBTrace_LoadTraceFromFile, METH_VARARGS, "See SBDebugger::LoadTraceFromFile."},
	 { "SBTrace_CreateNewCursor", _wrap_SBTrace_CreateNewCursor, METH_VARARGS, "\n"
		"Get a *TraceCursor* for the given thread's trace.\n"
		"\n"
		":type error: :py:class:`SBError`, out\n"
		":param error:\n"
		"      This will be set with an error in case of failures.\n"
		":type thread: :py:class:`SBThread`, in\n"
		":param thread:\n"
		"      The thread to get a *TraceCursor* for.\n"
		":rtype: :py:class:`SBTraceCursor`\n"
		":return: \n"
		"        A *SBTraceCursor*. If the thread is not traced or its trace\n"
		"        information failed to load, an invalid *SBTraceCursor* is returned\n"
		"        and the ``error`` parameter is set.\n"
		""},
	 { "SBTrace_SaveToDisk", _wrap_SBTrace_SaveToDisk, METH_VARARGS, "\n"
		"Save the trace to the specified directory, which will be created if\n"
		"needed. This will also create a file <directory>/trace.json with the\n"
		"main properties of the trace session, along with others files which\n"
		"contain the actual trace data. The trace.json file can be used later as\n"
		"input for the \"trace load\" command to load the trace in LLDB, or for the\n"
		"method *SBDebugger.LoadTraceFromFile()*.\n"
		"\n"
		":type error: :py:class:`SBError`, out\n"
		":param error:\n"
		"      This will be set with an error in case of failures.\n"
		"\n"
		":type bundle_dir: :py:class:`SBFileSpec`, in\n"
		":param bundle_dir:\n"
		"      The directory where the trace files will be saved.\n"
		"\n"
		":type compact: boolean, in, optional\n"
		":param compact:\n"
		"      Try not to save to disk information irrelevant to the traced processes.\n"
		"      Each trace plug-in implements this in a different fashion.\n"
		"\n"
		":rtype: :py:class:`SBFileSpec`\n"
		":return: \n"
		"      A *SBFileSpec* pointing to the bundle description file.\n"
		""},
	 { "SBTrace_GetStartConfigurationHelp", _wrap_SBTrace_GetStartConfigurationHelp, METH_O, "\n"
		":rtype: string\n"
		":return: \n"
		"        A description of the parameters to use for the *SBTrace::Start*\n"
		"        method, or **null** if the object is invalid.\n"
		""},
	 { "SBTrace_Start", _wrap_SBTrace_Start, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		" Start tracing all current and future threads in a live process using a\n"
		" provided configuration. This is referred as \"process tracing\" in the\n"
		" documentation.\n"
		"\n"
		" This is equivalent to the command \"process trace start\".\n"
		"\n"
		" This operation fails if it is invoked twice in a row without\n"
		" first stopping the process trace with *SBTrace::Stop()*.\n"
		"\n"
		" If a thread is already being traced explicitly, e.g. with\n"
		"*SBTrace::Start(const* SBThread &thread, const SBStructuredData\n"
		" &configuration), it is left unaffected by this operation.\n"
		"\n"
		" :type configuration: :py:class:`SBStructuredData`, in\n"
		" :param configuration:\n"
		"         Dictionary object with custom fields for the corresponding trace\n"
		"         technology.\n"
		"\n"
		"     Full details for the trace start parameters that can be set can be\n"
		"     retrieved by calling *SBTrace::GetStartConfigurationHelp()*.\n"
		"\n"
		" :rtype: :py:class:`SBError`\n"
		" :return: \n"
		"         An error explaining any failures.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		" Start tracing a specific thread in a live process using a provided\n"
		" configuration. This is referred as \"thread tracing\" in the documentation.\n"
		"\n"
		" This is equivalent to the command \"thread trace start\".\n"
		"\n"
		" If the thread is already being traced by a \"process tracing\" operation,\n"
		" e.g. with *SBTrace::Start(const* SBStructuredData &configuration), this\n"
		" operation fails.\n"
		"\n"
		" :type configuration: :py:class:`SBStructuredData`, in\n"
		" :param configuration:\n"
		"         Dictionary object with custom fields for the corresponding trace\n"
		"         technology.\n"
		"\n"
		"     Full details for the trace start parameters that can be set can be\n"
		"     retrieved by calling *SBTrace::GetStartConfigurationHelp()*.\n"
		"\n"
		" :rtype: :py:class:`SBError`\n"
		" :return: \n"
		"         An error explaining any failures.\n"
		""},
	 { "SBTrace_Stop", _wrap_SBTrace_Stop, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		"Stop tracing all threads in a live process.\n"
		"\n"
		"If a \"process tracing\" operation is active, e.g. *SBTrace::Start(const*\n"
		"SBStructuredData &configuration), this effectively prevents future threads\n"
		"from being traced.\n"
		"\n"
		"This is equivalent to the command \"process trace stop\".\n"
		"\n"
		":rtype: :py:class:`SBError`\n"
		":return: \n"
		"        An error explaining any failures.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		"Stop tracing a specific thread in a live process regardless of whether the\n"
		"thread was traced explicitly or as part of a \"process tracing\" operation.\n"
		"\n"
		"This is equivalent to the command \"thread trace stop\".\n"
		"\n"
		":rtype: :py:class:`SBError`\n"
		":return: \n"
		"        An error explaining any failures.\n"
		""},
	 { "SBTrace___nonzero__", _wrap_SBTrace___nonzero__, METH_O, "SBTrace___nonzero__(SBTrace self) -> bool"},
	 { "SBTrace_IsValid", _wrap_SBTrace_IsValid, METH_O, "SBTrace_IsValid(SBTrace self) -> bool"},
	 { "delete_SBTrace", _wrap_delete_SBTrace, METH_O, "delete_SBTrace(SBTrace self)"},
	 { "SBTrace_swigregister", SBTrace_swigregister, METH_O, NULL},
	 { "SBTrace_swiginit", SBTrace_swiginit, METH_VARARGS, NULL},
	 { "new_SBTraceCursor", _wrap_new_SBTraceCursor, METH_NOARGS, "Default constructor for an invalid *SBTraceCursor* object."},
	 { "SBTraceCursor_SetForwards", _wrap_SBTraceCursor_SetForwards, METH_VARARGS, "\n"
		"Set the direction to use in the *SBTraceCursor::Next()* method.\n"
		"\n"
		":type forwards: boolean, in\n"
		":param forwards:\n"
		"        If **true**, then the traversal will be forwards, otherwise backwards.\n"
		""},
	 { "SBTraceCursor_IsForwards", _wrap_SBTraceCursor_IsForwards, METH_O, "\n"
		"Check if the direction to use in the *SBTraceCursor::Next()* method is\n"
		"forwards.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"        **true** if the current direction is forwards, **false** if backwards.\n"
		""},
	 { "SBTraceCursor_Next", _wrap_SBTraceCursor_Next, METH_O, "\n"
		"Move the cursor to the next item (instruction or error).\n"
		"\n"
		"Direction:\n"
		"    The traversal is done following the current direction of the trace. If\n"
		"    it is forwards, the instructions are visited forwards\n"
		"    chronologically. Otherwise, the traversal is done in\n"
		"    the opposite direction. By default, a cursor moves backwards unless\n"
		"    changed with *SBTraceCursor::SetForwards()*.\n"
		""},
	 { "SBTraceCursor_HasValue", _wrap_SBTraceCursor_HasValue, METH_O, "\n"
		":rtype: boolean\n"
		":return: \n"
		"        **true** if the cursor is pointing to a valid item. **false** if the\n"
		"        cursor has reached the end of the trace.\n"
		""},
	 { "SBTraceCursor_GoToId", _wrap_SBTraceCursor_GoToId, METH_VARARGS, "\n"
		" Instruction identifiers:\n"
		"\n"
		" When building complex higher level tools, fast random accesses in the\n"
		" trace might be needed, for which each instruction requires a unique\n"
		" identifier within its thread trace. For example, a tool might want to\n"
		" repeatedly inspect random consecutive portions of a trace. This means that\n"
		" it will need to first move quickly to the beginning of each section and\n"
		" then start its iteration. Given that the number of instructions can be in\n"
		" the order of hundreds of millions, fast random access is necessary.\n"
		"\n"
		" An example of such a tool could be an inspector of the call graph of a\n"
		" trace, where each call is represented with its start and end instructions.\n"
		" Inspecting all the instructions of a call requires moving to its first\n"
		" instruction and then iterating until the last instruction, which following\n"
		" the pattern explained above.\n"
		"\n"
		" Instead of using 0-based indices as identifiers, each Trace plug-in can\n"
		" decide the nature of these identifiers and thus no assumptions can be made\n"
		" regarding their ordering and sequentiality. The reason is that an\n"
		" instruction might be encoded by the plug-in in a way that hides its actual\n"
		" 0-based index in the trace, but it's still possible to efficiently find\n"
		" it.\n"
		"\n"
		" Requirements:\n"
		" - For a given thread, no two instructions have the same id.\n"
		" - In terms of efficiency, moving the cursor to a given id should be as\n"
		"   fast as possible, but not necessarily O(1). That's why the recommended\n"
		"   way to traverse sequential instructions is to use the\n"
		"*SBTraceCursor::Next()* method and only use *SBTraceCursor::GoToId(id)*\n"
		"   sparingly.\n"
		" Make the cursor point to the item whose identifier is ``id``.\n"
		"\n"
		" :rtype: boolean\n"
		" :return: \n"
		"         **true** if the given identifier exists and the cursor effectively\n"
		"         moved to it. Otherwise, **false** is returned and the cursor now points\n"
		"         to an invalid item, i.e. calling *HasValue()* will return **false**.\n"
		""},
	 { "SBTraceCursor_HasId", _wrap_SBTraceCursor_HasId, METH_VARARGS, "\n"
		":rtype: boolean\n"
		":return: \n"
		"        **true** if and only if there's an instruction item with the given\n"
		"   ``id``.\n"
		""},
	 { "SBTraceCursor_GetId", _wrap_SBTraceCursor_GetId, METH_O, "\n"
		":rtype: int\n"
		":return: \n"
		"        A unique identifier for the instruction or error this cursor is\n"
		"        pointing to.\n"
		""},
	 { "SBTraceCursor_Seek", _wrap_SBTraceCursor_Seek, METH_VARARGS, "\n"
		"Make the cursor point to an item in the trace based on an origin point and\n"
		"an offset.\n"
		"\n"
		"The resulting position of the trace is\n"
		"    origin + offset\n"
		"\n"
		"If this resulting position would be out of bounds, the trace then points\n"
		"to an invalid item, i.e. calling *HasValue()* returns **false**.\n"
		"\n"
		":type offset: int, in\n"
		":param offset:\n"
		"        How many items to move forwards (if positive) or backwards (if\n"
		"        negative) from the given origin point. For example, if origin is\n"
		"   **End**, then a negative offset would move backward in the trace, but a\n"
		"        positive offset would move past the trace to an invalid item.\n"
		"\n"
		":type origin: int, in\n"
		":param origin:\n"
		"        The reference point to use when moving the cursor.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"        **true** if and only if the cursor ends up pointing to a valid item.\n"
		""},
	 { "SBTraceCursor_GetItemKind", _wrap_SBTraceCursor_GetItemKind, METH_O, "\n"
		"Trace item information (instructions, errors and events)\n"
		"\n"
		":rtype: int\n"
		":return: \n"
		"        The kind of item the cursor is pointing at.\n"
		""},
	 { "SBTraceCursor_IsError", _wrap_SBTraceCursor_IsError, METH_O, "\n"
		":rtype: boolean\n"
		":return: \n"
		"        Whether the cursor points to an error or not.\n"
		""},
	 { "SBTraceCursor_GetError", _wrap_SBTraceCursor_GetError, METH_O, "\n"
		":rtype: string\n"
		":return: \n"
		"        The error message the cursor is pointing at.\n"
		""},
	 { "SBTraceCursor_IsEvent", _wrap_SBTraceCursor_IsEvent, METH_O, "\n"
		":rtype: boolean\n"
		":return: \n"
		"        Whether the cursor points to an event or not.\n"
		""},
	 { "SBTraceCursor_GetEventType", _wrap_SBTraceCursor_GetEventType, METH_O, "\n"
		":rtype: int\n"
		":return: \n"
		"        The specific kind of event the cursor is pointing at.\n"
		""},
	 { "SBTraceCursor_GetEventTypeAsString", _wrap_SBTraceCursor_GetEventTypeAsString, METH_O, "\n"
		":rtype: string\n"
		":return: \n"
		"        A human-readable description of the event this cursor is pointing at.\n"
		""},
	 { "SBTraceCursor_IsInstruction", _wrap_SBTraceCursor_IsInstruction, METH_O, "\n"
		":rtype: boolean\n"
		":return: \n"
		"        Whether the cursor points to an instruction.\n"
		""},
	 { "SBTraceCursor_GetLoadAddress", _wrap_SBTraceCursor_GetLoadAddress, METH_O, "\n"
		":rtype: int\n"
		":return: \n"
		"        The load address of the instruction the cursor is pointing at.\n"
		""},
	 { "SBTraceCursor_GetCPU", _wrap_SBTraceCursor_GetCPU, METH_O, "\n"
		":rtype: int\n"
		":return: \n"
		"       The requested CPU id, or LLDB_INVALID_CPU_ID if this information is\n"
		"       not available for the current item.\n"
		""},
	 { "SBTraceCursor_IsValid", _wrap_SBTraceCursor_IsValid, METH_O, "SBTraceCursor_IsValid(SBTraceCursor self) -> bool"},
	 { "SBTraceCursor___nonzero__", _wrap_SBTraceCursor___nonzero__, METH_O, "SBTraceCursor___nonzero__(SBTraceCursor self) -> bool"},
	 { "delete_SBTraceCursor", _wrap_delete_SBTraceCursor, METH_O, "delete_SBTraceCursor(SBTraceCursor self)"},
	 { "SBTraceCursor_swigregister", SBTraceCursor_swigregister, METH_O, NULL},
	 { "SBTraceCursor_swiginit", SBTraceCursor_swiginit, METH_VARARGS, NULL},
	 { "new_SBTypeMember", _wrap_new_SBTypeMember, METH_VARARGS, "\n"
		"SBTypeMember()\n"
		"new_SBTypeMember(SBTypeMember rhs) -> SBTypeMember\n"
		""},
	 { "delete_SBTypeMember", _wrap_delete_SBTypeMember, METH_O, "delete_SBTypeMember(SBTypeMember self)"},
	 { "SBTypeMember___nonzero__", _wrap_SBTypeMember___nonzero__, METH_O, "SBTypeMember___nonzero__(SBTypeMember self) -> bool"},
	 { "SBTypeMember_IsValid", _wrap_SBTypeMember_IsValid, METH_O, "SBTypeMember_IsValid(SBTypeMember self) -> bool"},
	 { "SBTypeMember_GetName", _wrap_SBTypeMember_GetName, METH_O, "SBTypeMember_GetName(SBTypeMember self) -> char const *"},
	 { "SBTypeMember_GetType", _wrap_SBTypeMember_GetType, METH_O, "SBTypeMember_GetType(SBTypeMember self) -> SBType"},
	 { "SBTypeMember_GetOffsetInBytes", _wrap_SBTypeMember_GetOffsetInBytes, METH_O, "SBTypeMember_GetOffsetInBytes(SBTypeMember self) -> uint64_t"},
	 { "SBTypeMember_GetOffsetInBits", _wrap_SBTypeMember_GetOffsetInBits, METH_O, "SBTypeMember_GetOffsetInBits(SBTypeMember self) -> uint64_t"},
	 { "SBTypeMember_IsBitfield", _wrap_SBTypeMember_IsBitfield, METH_O, "SBTypeMember_IsBitfield(SBTypeMember self) -> bool"},
	 { "SBTypeMember_GetBitfieldSizeInBits", _wrap_SBTypeMember_GetBitfieldSizeInBits, METH_O, "SBTypeMember_GetBitfieldSizeInBits(SBTypeMember self) -> uint32_t"},
	 { "SBTypeMember_GetDescription", _wrap_SBTypeMember_GetDescription, METH_VARARGS, "SBTypeMember_GetDescription(SBTypeMember self, SBStream description, lldb::DescriptionLevel description_level) -> bool"},
	 { "SBTypeMember___repr__", _wrap_SBTypeMember___repr__, METH_O, "SBTypeMember___repr__(SBTypeMember self) -> std::string"},
	 { "SBTypeMember_swigregister", SBTypeMember_swigregister, METH_O, NULL},
	 { "SBTypeMember_swiginit", SBTypeMember_swiginit, METH_VARARGS, NULL},
	 { "new_SBTypeMemberFunction", _wrap_new_SBTypeMemberFunction, METH_VARARGS, "\n"
		"SBTypeMemberFunction()\n"
		"new_SBTypeMemberFunction(SBTypeMemberFunction rhs) -> SBTypeMemberFunction\n"
		""},
	 { "delete_SBTypeMemberFunction", _wrap_delete_SBTypeMemberFunction, METH_O, "delete_SBTypeMemberFunction(SBTypeMemberFunction self)"},
	 { "SBTypeMemberFunction___nonzero__", _wrap_SBTypeMemberFunction___nonzero__, METH_O, "SBTypeMemberFunction___nonzero__(SBTypeMemberFunction self) -> bool"},
	 { "SBTypeMemberFunction_IsValid", _wrap_SBTypeMemberFunction_IsValid, METH_O, "SBTypeMemberFunction_IsValid(SBTypeMemberFunction self) -> bool"},
	 { "SBTypeMemberFunction_GetName", _wrap_SBTypeMemberFunction_GetName, METH_O, "SBTypeMemberFunction_GetName(SBTypeMemberFunction self) -> char const *"},
	 { "SBTypeMemberFunction_GetDemangledName", _wrap_SBTypeMemberFunction_GetDemangledName, METH_O, "SBTypeMemberFunction_GetDemangledName(SBTypeMemberFunction self) -> char const *"},
	 { "SBTypeMemberFunction_GetMangledName", _wrap_SBTypeMemberFunction_GetMangledName, METH_O, "SBTypeMemberFunction_GetMangledName(SBTypeMemberFunction self) -> char const *"},
	 { "SBTypeMemberFunction_GetType", _wrap_SBTypeMemberFunction_GetType, METH_O, "SBTypeMemberFunction_GetType(SBTypeMemberFunction self) -> SBType"},
	 { "SBTypeMemberFunction_GetReturnType", _wrap_SBTypeMemberFunction_GetReturnType, METH_O, "SBTypeMemberFunction_GetReturnType(SBTypeMemberFunction self) -> SBType"},
	 { "SBTypeMemberFunction_GetNumberOfArguments", _wrap_SBTypeMemberFunction_GetNumberOfArguments, METH_O, "SBTypeMemberFunction_GetNumberOfArguments(SBTypeMemberFunction self) -> uint32_t"},
	 { "SBTypeMemberFunction_GetArgumentTypeAtIndex", _wrap_SBTypeMemberFunction_GetArgumentTypeAtIndex, METH_VARARGS, "SBTypeMemberFunction_GetArgumentTypeAtIndex(SBTypeMemberFunction self, uint32_t arg2) -> SBType"},
	 { "SBTypeMemberFunction_GetKind", _wrap_SBTypeMemberFunction_GetKind, METH_O, "SBTypeMemberFunction_GetKind(SBTypeMemberFunction self) -> lldb::MemberFunctionKind"},
	 { "SBTypeMemberFunction_GetDescription", _wrap_SBTypeMemberFunction_GetDescription, METH_VARARGS, "SBTypeMemberFunction_GetDescription(SBTypeMemberFunction self, SBStream description, lldb::DescriptionLevel description_level) -> bool"},
	 { "SBTypeMemberFunction___repr__", _wrap_SBTypeMemberFunction___repr__, METH_O, "SBTypeMemberFunction___repr__(SBTypeMemberFunction self) -> std::string"},
	 { "SBTypeMemberFunction_swigregister", SBTypeMemberFunction_swigregister, METH_O, NULL},
	 { "SBTypeMemberFunction_swiginit", SBTypeMemberFunction_swiginit, METH_VARARGS, NULL},
	 { "new_SBTypeStaticField", _wrap_new_SBTypeStaticField, METH_VARARGS, "\n"
		"SBTypeStaticField()\n"
		"new_SBTypeStaticField(SBTypeStaticField rhs) -> SBTypeStaticField\n"
		""},
	 { "delete_SBTypeStaticField", _wrap_delete_SBTypeStaticField, METH_O, "delete_SBTypeStaticField(SBTypeStaticField self)"},
	 { "SBTypeStaticField___nonzero__", _wrap_SBTypeStaticField___nonzero__, METH_O, "SBTypeStaticField___nonzero__(SBTypeStaticField self) -> bool"},
	 { "SBTypeStaticField_IsValid", _wrap_SBTypeStaticField_IsValid, METH_O, "SBTypeStaticField_IsValid(SBTypeStaticField self) -> bool"},
	 { "SBTypeStaticField_GetName", _wrap_SBTypeStaticField_GetName, METH_O, "SBTypeStaticField_GetName(SBTypeStaticField self) -> char const *"},
	 { "SBTypeStaticField_GetMangledName", _wrap_SBTypeStaticField_GetMangledName, METH_O, "SBTypeStaticField_GetMangledName(SBTypeStaticField self) -> char const *"},
	 { "SBTypeStaticField_GetType", _wrap_SBTypeStaticField_GetType, METH_O, "SBTypeStaticField_GetType(SBTypeStaticField self) -> SBType"},
	 { "SBTypeStaticField_GetConstantValue", _wrap_SBTypeStaticField_GetConstantValue, METH_VARARGS, "SBTypeStaticField_GetConstantValue(SBTypeStaticField self, SBTarget target) -> SBValue"},
	 { "SBTypeStaticField_swigregister", SBTypeStaticField_swigregister, METH_O, NULL},
	 { "SBTypeStaticField_swiginit", SBTypeStaticField_swiginit, METH_VARARGS, NULL},
	 { "new_SBType", _wrap_new_SBType, METH_VARARGS, "\n"
		"SBType()\n"
		"new_SBType(SBType rhs) -> SBType\n"
		""},
	 { "delete_SBType", _wrap_delete_SBType, METH_O, "delete_SBType(SBType self)"},
	 { "SBType___nonzero__", _wrap_SBType___nonzero__, METH_O, "SBType___nonzero__(SBType self) -> bool"},
	 { "SBType_IsValid", _wrap_SBType_IsValid, METH_O, "SBType_IsValid(SBType self) -> bool"},
	 { "SBType_GetByteSize", _wrap_SBType_GetByteSize, METH_O, "\n"
		"SBType_GetByteSize(SBType self) -> uint64_t\n"
		"Returns the number of bytes a variable with the given types occupies in memory.\n"
		"\n"
		"    Returns ``0`` if the size can't be determined.\n"
		"\n"
		"    If a type occupies ``N`` bytes + ``M`` bits in memory, this function returns\n"
		"    the rounded up amount of bytes (i.e., if ``M`` is ``0``,\n"
		"    this function returns ``N`` and otherwise ``N + 1``).\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: The output is expected to match the value of ``sizeof(Type)``. If\n"
		"      ``sizeof(Type)`` is not a valid expression for the given type, the\n"
		"      function returns ``0``.\n"
		"    * C++: Same as in C.\n"
		"    * Objective-C: Same as in C. For Objective-C classes this always returns\n"
		"      ``0`` as the actual size depends on runtime information.\n"
		"\n"
		""},
	 { "SBType_GetByteAlign", _wrap_SBType_GetByteAlign, METH_O, "SBType_GetByteAlign(SBType self) -> uint64_t"},
	 { "SBType_IsPointerType", _wrap_SBType_IsPointerType, METH_O, "\n"
		"SBType_IsPointerType(SBType self) -> bool\n"
		"Returns true if this type is a pointer type.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns true for C pointer types (or typedefs of these types).\n"
		"    * C++: Pointer types include the C pointer types as well as pointers to data\n"
		"      mebers or member functions.\n"
		"    * Objective-C: Pointer types include the C pointer types. ``id``, ``Class``\n"
		"      and pointers to blocks are also considered pointer types.\n"
		"\n"
		""},
	 { "SBType_IsReferenceType", _wrap_SBType_IsReferenceType, METH_O, "\n"
		"SBType_IsReferenceType(SBType self) -> bool\n"
		"Returns true if this type is a reference type.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns false for all types.\n"
		"    * C++: Both l-value and r-value references are considered reference types.\n"
		"    * Objective-C: Returns false for all types.\n"
		"\n"
		""},
	 { "SBType_IsFunctionType", _wrap_SBType_IsFunctionType, METH_O, "SBType_IsFunctionType(SBType self) -> bool"},
	 { "SBType_IsPolymorphicClass", _wrap_SBType_IsPolymorphicClass, METH_O, "\n"
		"SBType_IsPolymorphicClass(SBType self) -> bool\n"
		"Returns true if this type is a polymorphic type.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns false for all types.\n"
		"    * C++: Returns true if the type is a class type that contains at least one\n"
		"      virtual member function or if at least one of its base classes is\n"
		"      considered a polymorphic type.\n"
		"    * Objective-C: Returns false for all types.\n"
		"\n"
		""},
	 { "SBType_IsArrayType", _wrap_SBType_IsArrayType, METH_O, "\n"
		"SBType_IsArrayType(SBType self) -> bool\n"
		"Returns true if this type is an array type.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns true if the types is an array type. This includes incomplete\n"
		"      array types ``T[]`` and array types with integer (``T[1]``) or variable\n"
		"      length (``T[some_variable]``). Pointer types are not considered arrays.\n"
		"    * C++: Includes C's array types and dependent array types (i.e., array types\n"
		"      in templates which size depends on template arguments).\n"
		"    * Objective-C: Same as in C.\n"
		"\n"
		""},
	 { "SBType_IsVectorType", _wrap_SBType_IsVectorType, METH_O, "\n"
		"SBType_IsVectorType(SBType self) -> bool\n"
		"Returns true if this type is a vector type.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns true if the types is a vector type created with\n"
		"      GCC's ``vector_size`` or Clang's ``ext_vector_type`` feature.\n"
		"    * C++: Same as in C.\n"
		"    * Objective-C: Same as in C.\n"
		"\n"
		""},
	 { "SBType_IsTypedefType", _wrap_SBType_IsTypedefType, METH_O, "\n"
		"SBType_IsTypedefType(SBType self) -> bool\n"
		"Returns true if this type is a typedef.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns true if the type is a C typedef.\n"
		"    * C++: Same as in C. Also treats type aliases as typedefs.\n"
		"    * Objective-C: Same as in C.\n"
		"\n"
		""},
	 { "SBType_IsAnonymousType", _wrap_SBType_IsAnonymousType, METH_O, "\n"
		"SBType_IsAnonymousType(SBType self) -> bool\n"
		"Returns true if this type is an anonymous type.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns true for anonymous unions. Also returns true for\n"
		"      anonymous structs (which are a GNU language extension).\n"
		"    * C++: Same as in C.\n"
		"    * Objective-C: Same as in C.\n"
		"\n"
		""},
	 { "SBType_IsScopedEnumerationType", _wrap_SBType_IsScopedEnumerationType, METH_O, "\n"
		"SBType_IsScopedEnumerationType(SBType self) -> bool\n"
		"Returns true if this type is a scoped enum.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns false for all types.\n"
		"    * C++: Return true only for C++11 scoped enums.\n"
		"    * Objective-C: Returns false for all types.\n"
		"\n"
		""},
	 { "SBType_IsAggregateType", _wrap_SBType_IsAggregateType, METH_O, "\n"
		"SBType_IsAggregateType(SBType self) -> bool\n"
		"Returns true if this type is an aggregate type.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns true for struct values, arrays, and vectors.\n"
		"    * C++: Same a C. Also includes class instances.\n"
		"    * Objective-C: Same as C. Also includes class instances.\n"
		"\n"
		""},
	 { "SBType_GetPointerType", _wrap_SBType_GetPointerType, METH_O, "\n"
		"SBType_GetPointerType(SBType self) -> SBType\n"
		"Returns a type that represents a pointer to this type.\n"
		"\n"
		"    If the type system of the current language can't represent a pointer to this\n"
		"    type or this type is invalid, an invalid `SBType` is returned.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns the pointer type of this type.\n"
		"    * C++: Same as in C.\n"
		"    * Objective-C: Same as in C.\n"
		"\n"
		""},
	 { "SBType_GetPointeeType", _wrap_SBType_GetPointeeType, METH_O, "\n"
		"SBType_GetPointeeType(SBType self) -> SBType\n"
		"Returns the underlying pointee type.\n"
		"\n"
		"    If this type is a pointer type as specified by `IsPointerType` then this\n"
		"    returns the underlying type. If this is not a pointer type or an invalid\n"
		"    `SBType` then this returns an invalid `SBType`.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns the underlying type for for C pointer types or typedefs of\n"
		"      these types). For example, ``int *`` will return ``int``.\n"
		"    * C++: Same as in C. Returns an `SBType` representation for data members/\n"
		"      member functions in case the `SBType` is a pointer to data member or\n"
		"      pointer to member function.\n"
		"    * Objective-C: Same as in C. The pointee type of ``id`` and ``Class`` is\n"
		"      an invalid `SBType`. The pointee type of pointers Objective-C types is an\n"
		"      `SBType` for the non-pointer type of the respective type. For example,\n"
		"      ``NSString *`` will return ``NSString`` as a pointee type.\n"
		"\n"
		""},
	 { "SBType_GetReferenceType", _wrap_SBType_GetReferenceType, METH_O, "\n"
		"SBType_GetReferenceType(SBType self) -> SBType\n"
		"Returns a type that represents a reference to this type.\n"
		"\n"
		"    If the type system of the current language can't represent a reference to\n"
		"    this type, an invalid `SBType` is returned.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Currently assumes the type system is C++ and returns an l-value\n"
		"      reference type. For example, ``int`` will return ``int&``. This behavior\n"
		"      is likely to change in the future and shouldn't be relied on.\n"
		"    * C++: Same as in C.\n"
		"    * Objective-C: Same as in C.\n"
		"\n"
		""},
	 { "SBType_GetTypedefedType", _wrap_SBType_GetTypedefedType, METH_O, "\n"
		"SBType_GetTypedefedType(SBType self) -> SBType\n"
		"Returns the underlying type of a typedef.\n"
		"\n"
		"    If this type is a typedef as designated by `IsTypedefType`, then the\n"
		"    underlying type is being returned. Otherwise an invalid `SBType` is\n"
		"    returned.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns the underlying type of a typedef type.\n"
		"    * C++: Same as in C. For type aliases, the underlying type is returned.\n"
		"    * Objective-C: Same as in C.\n"
		"\n"
		""},
	 { "SBType_GetDereferencedType", _wrap_SBType_GetDereferencedType, METH_O, "\n"
		"SBType_GetDereferencedType(SBType self) -> SBType\n"
		"Returns the underlying type of a reference type.\n"
		"\n"
		"    If this type is a reference as designated by `IsReferenceType`, then the\n"
		"    underlying type is being returned. Otherwise an invalid `SBType` is\n"
		"    returned.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Always returns an invalid type.\n"
		"    * C++: For l-value and r-value references the underlying type is returned.\n"
		"      For example, ``int &`` will return ``int``.\n"
		"    * Objective-C: Same as in C.\n"
		"\n"
		""},
	 { "SBType_GetUnqualifiedType", _wrap_SBType_GetUnqualifiedType, METH_O, "\n"
		"SBType_GetUnqualifiedType(SBType self) -> SBType\n"
		"Returns the unqualified version of this type.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: If this type with any const or volatile specifier removed.\n"
		"    * C++: Same as in C.\n"
		"    * Objective-C: Same as in C.\n"
		"\n"
		""},
	 { "SBType_GetArrayElementType", _wrap_SBType_GetArrayElementType, METH_O, "\n"
		"SBType_GetArrayElementType(SBType self) -> SBType\n"
		"Returns the array element type if this type is an array type.\n"
		"\n"
		"    Otherwise returns an invalid `SBType` if this type is invalid or not an\n"
		"    array type.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: If this is an array type (see `IsArrayType`) such as ``T[]``, returns\n"
		"      the element type.\n"
		"    * C++: Same as in C.\n"
		"    * Objective-C: Same as in C.\n"
		"\n"
		"    See also `IsArrayType`.\n"
		"\n"
		""},
	 { "SBType_GetArrayType", _wrap_SBType_GetArrayType, METH_VARARGS, "\n"
		"SBType_GetArrayType(SBType self, uint64_t size) -> SBType\n"
		"Returns the array type with the given constant size.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns a constant-size array ``T[size]`` for any non-void type.\n"
		"    * C++: Same as in C.\n"
		"    * Objective-C: Same as in C.\n"
		"\n"
		"    See also `IsArrayType` and `GetArrayElementType`.\n"
		"\n"
		""},
	 { "SBType_GetVectorElementType", _wrap_SBType_GetVectorElementType, METH_O, "\n"
		"SBType_GetVectorElementType(SBType self) -> SBType\n"
		"Returns the vector element type if this type is a vector type.\n"
		"\n"
		"    Otherwise returns an invalid `SBType` if this type is invalid or not a\n"
		"    vector type.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: If this is a vector type (see `IsVectorType`), returns the element\n"
		"      type.\n"
		"    * C++: Same as in C.\n"
		"    * Objective-C: Same as in C.\n"
		"\n"
		"    See also `IsVectorType`.\n"
		"\n"
		""},
	 { "SBType_GetCanonicalType", _wrap_SBType_GetCanonicalType, METH_O, "SBType_GetCanonicalType(SBType self) -> SBType"},
	 { "SBType_GetEnumerationIntegerType", _wrap_SBType_GetEnumerationIntegerType, METH_O, "\n"
		"SBType_GetEnumerationIntegerType(SBType self) -> SBType\n"
		"Returns the underlying integer type if this is an enumeration type.\n"
		"\n"
		"    If this type is an invalid `SBType` or not an enumeration type an invalid\n"
		"    `SBType` is returned.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns the underlying type for enums.\n"
		"    * C++: Same as in C but also returns the underlying type for scoped enums.\n"
		"    * Objective-C: Same as in C.\n"
		"\n"
		""},
	 { "SBType_GetBasicType", _wrap_SBType_GetBasicType, METH_VARARGS, "\n"
		"SBType_GetBasicType(SBType self) -> lldb::BasicType\n"
		"SBType_GetBasicType(SBType self, lldb::BasicType type) -> SBType\n"
		"Returns the `BasicType` value that is most appropriate to this type.\n"
		"\n"
		"    Returns `eBasicTypeInvalid` if no appropriate `BasicType` was found or this\n"
		"    type is invalid. See the `BasicType` documentation for the language-specific\n"
		"    meaning of each `BasicType` value.\n"
		"\n"
		"    **Overload behaviour:** When called with a `BasicType` parameter, the\n"
		"    following behaviour applies:\n"
		"\n"
		"    Returns the `SBType` that represents the passed `BasicType` value. Returns\n"
		"    an invalid `SBType` if no fitting `SBType` could be created.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns the respective builtin type. Note that some types\n"
		"      (e.g. ``__uint128_t``) might even be successfully created even if they are\n"
		"      not available on the target platform. C++ and Objective-C specific types\n"
		"      might also be created even if the target program is not written in C++ or\n"
		"      Objective-C.\n"
		"    * C++: Same as in C.\n"
		"    * Objective-C: Same as in C.\n"
		"\n"
		""},
	 { "SBType_GetNumberOfFields", _wrap_SBType_GetNumberOfFields, METH_O, "\n"
		"SBType_GetNumberOfFields(SBType self) -> uint32_t\n"
		"Returns the number of fields of this type.\n"
		"\n"
		"    Returns ``0`` if this type does not have fields.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns the number of fields if the type is a struct. If the type\n"
		"      contains an anonymous struct/union it only counts as a single field (even\n"
		"      if the struct/union contains several fields).\n"
		"    * C++: Returns the number of non-static fields if the type is a\n"
		"      struct/class. If the type contains an anonymous struct/union it only\n"
		"      counts as a single field (even if the struct/union contains several\n"
		"      fields). The fields of any base classes are not included in the count.\n"
		"    * Objective-C: Same as in C for structs. For Objective-C classes the number\n"
		"      of ivars is returned.\n"
		"\n"
		"    See also `GetFieldAtIndex`.\n"
		"\n"
		""},
	 { "SBType_GetNumberOfDirectBaseClasses", _wrap_SBType_GetNumberOfDirectBaseClasses, METH_O, "\n"
		"SBType_GetNumberOfDirectBaseClasses(SBType self) -> uint32_t\n"
		"Returns the number of base/parent classes of this type.\n"
		"\n"
		"    Returns ``0`` if this type doesn't have any base classes.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns always ``0``.\n"
		"    * C++: The number of direct non-virtual base classes if this type is\n"
		"      a class.\n"
		"    * Objective-C: The number of super classes for Objective-C classes.\n"
		"      As Objective-C doesn't have multiple inheritance this is usually returns 1\n"
		"      except for NSObject.\n"
		"\n"
		""},
	 { "SBType_GetNumberOfVirtualBaseClasses", _wrap_SBType_GetNumberOfVirtualBaseClasses, METH_O, "\n"
		"SBType_GetNumberOfVirtualBaseClasses(SBType self) -> uint32_t\n"
		"Returns the number of virtual base/parent classes of this type\n"
		"\n"
		"    Returns ``0`` if this type doesn't have any base classes.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns always ``0``.\n"
		"    * C++: The number of direct virtual base classes if this type is a\n"
		"      class.\n"
		"    * Objective-C: Returns always ``0``.\n"
		"\n"
		""},
	 { "SBType_GetFieldAtIndex", _wrap_SBType_GetFieldAtIndex, METH_VARARGS, "\n"
		"SBType_GetFieldAtIndex(SBType self, uint32_t idx) -> SBTypeMember\n"
		"Returns the field at the given index.\n"
		"\n"
		"    Returns an invalid `SBType` if the index is out of range or the current\n"
		"    type doesn't have any fields.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns the field with the given index for struct types. Fields are\n"
		"      ordered/indexed starting from ``0`` for the first field in a struct (as\n"
		"      declared in the definition).\n"
		"    * C++: Returns the non-static field with the given index for struct types.\n"
		"      Fields are ordered/indexed starting from ``0`` for the first field in a\n"
		"      struct (as declared in the definition).\n"
		"    * Objective-C: Same as in C for structs. For Objective-C classes the ivar\n"
		"      with the given index is returned. ivars are indexed starting from ``0``.\n"
		"\n"
		""},
	 { "SBType_GetDirectBaseClassAtIndex", _wrap_SBType_GetDirectBaseClassAtIndex, METH_VARARGS, "\n"
		"SBType_GetDirectBaseClassAtIndex(SBType self, uint32_t idx) -> SBTypeMember\n"
		"Returns the direct base class as indexed by `GetNumberOfDirectBaseClasses`.\n"
		"\n"
		"    Returns an invalid SBTypeMember if the index is invalid or this SBType is\n"
		"    invalid.\n"
		"\n"
		""},
	 { "SBType_GetVirtualBaseClassAtIndex", _wrap_SBType_GetVirtualBaseClassAtIndex, METH_VARARGS, "\n"
		"SBType_GetVirtualBaseClassAtIndex(SBType self, uint32_t idx) -> SBTypeMember\n"
		"Returns the virtual base class as indexed by\n"
		"    `GetNumberOfVirtualBaseClasses`.\n"
		"\n"
		"    Returns an invalid SBTypeMember if the index is invalid or this SBType is\n"
		"    invalid.\n"
		"\n"
		""},
	 { "SBType_GetStaticFieldWithName", _wrap_SBType_GetStaticFieldWithName, METH_VARARGS, "SBType_GetStaticFieldWithName(SBType self, char const * name) -> SBTypeStaticField"},
	 { "SBType_GetEnumMembers", _wrap_SBType_GetEnumMembers, METH_O, "SBType_GetEnumMembers(SBType self) -> SBTypeEnumMemberList"},
	 { "SBType_GetNumberOfTemplateArguments", _wrap_SBType_GetNumberOfTemplateArguments, METH_O, "\n"
		"SBType_GetNumberOfTemplateArguments(SBType self) -> uint32_t\n"
		"Returns the number of template arguments of this type.\n"
		"\n"
		"    Returns ``0`` if this type is not a template.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Always returns ``0``.\n"
		"    * C++: If this type is a class template instantiation then this returns the\n"
		"      number of template parameters that were used in this instantiation. This\n"
		"      includes both explicit and implicit template parameters.\n"
		"    * Objective-C: Always returns ``0``.\n"
		"\n"
		""},
	 { "SBType_GetTemplateArgumentType", _wrap_SBType_GetTemplateArgumentType, METH_VARARGS, "\n"
		"SBType_GetTemplateArgumentType(SBType self, uint32_t idx) -> SBType\n"
		"Returns the type of the template argument with the given index.\n"
		"\n"
		"    Returns an invalid `SBType` if there is no template argument with the given\n"
		"    index or this type is not a template. The first template  argument has the\n"
		"    index ``0``.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Always returns an invalid SBType.\n"
		"    * C++: If this type is a class template instantiation and the template\n"
		"      parameter with the given index is a type template parameter, then this\n"
		"      returns the type of that parameter. Otherwise returns an invalid `SBType`.\n"
		"    * Objective-C: Always returns an invalid SBType.\n"
		"\n"
		""},
	 { "SBType_GetTemplateArgumentValue", _wrap_SBType_GetTemplateArgumentValue, METH_VARARGS, "\n"
		"Returns the value of the non-type template parameter at index ``idx``.\n"
		"If ``idx`` is out-of-bounds or the template parameter doesn't have\n"
		"a value, returns an empty SBValue.\n"
		"\n"
		"This function will expand parameter packs.\n"
		""},
	 { "SBType_GetTemplateArgumentKind", _wrap_SBType_GetTemplateArgumentKind, METH_VARARGS, "\n"
		"SBType_GetTemplateArgumentKind(SBType self, uint32_t idx) -> lldb::TemplateArgumentKind\n"
		"Returns the kind of the template argument with the given index.\n"
		"\n"
		"    Returns `eTemplateArgumentKindNull` if there is no template argument\n"
		"    with the given index or this type is not a template. The first template\n"
		"    argument has the index ``0``.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Always returns `eTemplateArgumentKindNull`.\n"
		"    * C++: If this type is a class template instantiation then this returns\n"
		"      the appropriate `TemplateArgument` value for the parameter with the given\n"
		"      index. See the documentation of `TemplateArgument` for how certain C++\n"
		"      template parameter kinds are mapped to `TemplateArgument` values.\n"
		"    * Objective-C: Always returns `eTemplateArgumentKindNull`.\n"
		"\n"
		""},
	 { "SBType_GetFunctionReturnType", _wrap_SBType_GetFunctionReturnType, METH_O, "\n"
		"SBType_GetFunctionReturnType(SBType self) -> SBType\n"
		"Returns the return type if this type represents a function.\n"
		"\n"
		"    Returns an invalid `SBType` if this type is not a function type or invalid.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: For functions return the return type. Returns an invalid `SBType` if\n"
		"      this type is a function pointer type.\n"
		"    * C++: Same as in C for functions and instantiated template functions.\n"
		"      Member functions are also considered functions. For functions that have\n"
		"      their return type specified by a placeholder type specifier (``auto``)\n"
		"      this returns the deduced return type.\n"
		"    * Objective-C: Same as in C for functions. For Objective-C methods this\n"
		"      returns the return type of the method.\n"
		"\n"
		""},
	 { "SBType_GetFunctionArgumentTypes", _wrap_SBType_GetFunctionArgumentTypes, METH_O, "\n"
		"SBType_GetFunctionArgumentTypes(SBType self) -> SBTypeList\n"
		"Returns the list of argument types if this type represents a function.\n"
		"\n"
		"    Returns an invalid `SBType` if this type is not a function type or invalid.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: For functions return the types of each parameter. Returns an invalid\n"
		"      `SBType` if this type is a function pointer. For variadic functions this\n"
		"      just returns the list of parameters before the variadic arguments.\n"
		"    * C++: Same as in C for functions and instantiated template functions.\n"
		"      Member functions are also considered functions.\n"
		"    * Objective-C: Always returns an invalid SBType for Objective-C methods.\n"
		"\n"
		""},
	 { "SBType_GetNumberOfMemberFunctions", _wrap_SBType_GetNumberOfMemberFunctions, METH_O, "\n"
		"SBType_GetNumberOfMemberFunctions(SBType self) -> uint32_t\n"
		"Returns the number of member functions of this type.\n"
		"\n"
		"    Returns ``0`` if an error occurred or this type is invalid.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Always returns ``0``.\n"
		"    * C++: If this type represents a struct/class, then the number of\n"
		"      member functions (static and non-static) is returned. The count includes\n"
		"      constructors and destructors (both explicit and implicit). Member\n"
		"      functions of base classes are not included in the count.\n"
		"    * Objective-C: If this type represents a struct/class, then the\n"
		"      number of methods is returned. Methods in categories or super classes\n"
		"      are not counted.\n"
		"\n"
		""},
	 { "SBType_GetMemberFunctionAtIndex", _wrap_SBType_GetMemberFunctionAtIndex, METH_VARARGS, "\n"
		"SBType_GetMemberFunctionAtIndex(SBType self, uint32_t idx) -> SBTypeMemberFunction\n"
		"Returns the member function of this type with the given index.\n"
		"\n"
		"    Returns an invalid `SBTypeMemberFunction` if the index is invalid or this\n"
		"    type is invalid.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Always returns an invalid `SBTypeMemberFunction`.\n"
		"    * C++: Returns the member function or constructor/destructor with the given\n"
		"      index.\n"
		"    * Objective-C: Returns the method with the given index.\n"
		"\n"
		"    See `GetNumberOfMemberFunctions` for what functions can be queried by this\n"
		"    function.\n"
		"\n"
		""},
	 { "SBType_GetModule", _wrap_SBType_GetModule, METH_O, "\n"
		"SBType_GetModule(SBType self) -> SBModule\n"
		"Returns the `SBModule` this `SBType` belongs to.\n"
		"\n"
		"    Returns no `SBModule` if this type does not belong to any specific\n"
		"    `SBModule` or this `SBType` is invalid. An invalid `SBModule` might also\n"
		"    indicate that once came from an `SBModule` but LLDB could no longer\n"
		"    determine the original module.\n"
		"\n"
		""},
	 { "SBType_GetName", _wrap_SBType_GetName, METH_O, "\n"
		"GetName() -> string\n"
		"Returns the name of this type.\n"
		"\n"
		"    Returns an empty string if an error occurred or this type is invalid.\n"
		"\n"
		"    Use this function when trying to match a specific type by name in a script.\n"
		"    The names returned by this function try to uniquely identify a name but\n"
		"    conflicts can occur (for example, if a C++ program contains two different\n"
		"    classes with the same name in different translation units. `GetName` can\n"
		"    return the same name for both class types.)\n"
		"\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: The name of the type. For structs the ``struct`` prefix is omitted.\n"
		"    * C++: Returns the qualified name of the type (including anonymous/inline\n"
		"      namespaces and all template arguments).\n"
		"    * Objective-C: Same as in C.\n"
		"\n"
		""},
	 { "SBType_GetDisplayTypeName", _wrap_SBType_GetDisplayTypeName, METH_O, "\n"
		"GetDisplayTypeName() -> string\n"
		"Returns the name of this type in a user-friendly format.\n"
		"\n"
		"    Returns an empty string if an error occurred or this type is invalid.\n"
		"\n"
		"    Use this function when displaying a type name to the user.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns the type name. For structs the ``struct`` prefix is omitted.\n"
		"    * C++: Returns the qualified name. Anonymous/inline namespaces are omitted.\n"
		"      Template arguments that match their default value might also be hidden\n"
		"      (this functionality depends on whether LLDB can determine the template's\n"
		"      default arguments).\n"
		"    * Objective-C: Same as in C.\n"
		"\n"
		""},
	 { "SBType_GetTypeClass", _wrap_SBType_GetTypeClass, METH_O, "\n"
		"GetTypeClass() -> TypeClass\n"
		"Returns the `TypeClass` for this type.\n"
		"\n"
		"    Returns an `eTypeClassInvalid` if this `SBType` is invalid.\n"
		"\n"
		"    See `TypeClass` for the language-specific meaning of each `TypeClass` value.\n"
		"\n"
		""},
	 { "SBType_IsTypeComplete", _wrap_SBType_IsTypeComplete, METH_O, "\n"
		"SBType_IsTypeComplete(SBType self) -> bool\n"
		"Returns true if the type is completely defined.\n"
		"\n"
		"    Language-specific behaviour:\n"
		"\n"
		"    * C: Returns false for struct types that were only forward declared in the\n"
		"      type's `SBTarget`/`SBModule`. Otherwise returns true.\n"
		"    * C++: Returns false for template/non-template struct/class types and\n"
		"      scoped enums that were only forward declared inside the type's\n"
		"      `SBTarget`/`SBModule`. Otherwise returns true.\n"
		"    * Objective-C: Follows the same behavior as C for struct types. Objective-C\n"
		"      classes are considered complete unless they were only forward declared via\n"
		"      ``@class ClassName`` in the type's `SBTarget`/`SBModule`. Otherwise\n"
		"      returns true.\n"
		"\n"
		""},
	 { "SBType_GetTypeFlags", _wrap_SBType_GetTypeFlags, METH_O, "\n"
		"SBType_GetTypeFlags(SBType self) -> uint32_t\n"
		"Returns the `TypeFlags` values for this type.\n"
		"\n"
		"    See the respective `TypeFlags` values for what values can be set. Returns an\n"
		"    integer in which each `TypeFlags` value is represented by a bit. Specific\n"
		"    flags can be checked via Python's bitwise operators. For example, the\n"
		"    `eTypeIsInteger` flag can be checked like this:\n"
		"\n"
		"    ``(an_sb_type.GetTypeFlags() & lldb.eTypeIsInteger) != 0``\n"
		"\n"
		"    If this type is invalid this returns ``0``.\n"
		"\n"
		"    See the different values for `TypeFlags` for the language-specific meanings\n"
		"    of each `TypeFlags` value.\n"
		"\n"
		""},
	 { "SBType_GetDescription", _wrap_SBType_GetDescription, METH_VARARGS, "SBType_GetDescription(SBType self, SBStream description, lldb::DescriptionLevel description_level) -> bool"},
	 { "SBType_FindDirectNestedType", _wrap_SBType_FindDirectNestedType, METH_VARARGS, "\n"
		"SBType_FindDirectNestedType(SBType self, char const * name) -> SBType\n"
		"Searches for a directly nested type that has the provided name.\n"
		"\n"
		"    Returns the type if it was found.\n"
		"    Returns invalid type if nothing was found.\n"
		"\n"
		""},
	 { "SBType___eq__", _wrap_SBType___eq__, METH_VARARGS, "SBType___eq__(SBType self, SBType rhs) -> bool"},
	 { "SBType___ne__", _wrap_SBType___ne__, METH_VARARGS, "SBType___ne__(SBType self, SBType rhs) -> bool"},
	 { "SBType___repr__", _wrap_SBType___repr__, METH_O, "SBType___repr__(SBType self) -> std::string"},
	 { "SBType_swigregister", SBType_swigregister, METH_O, NULL},
	 { "SBType_swiginit", SBType_swiginit, METH_VARARGS, NULL},
	 { "new_SBTypeList", _wrap_new_SBTypeList, METH_VARARGS, "\n"
		"SBTypeList()\n"
		"new_SBTypeList(SBTypeList rhs) -> SBTypeList\n"
		""},
	 { "delete_SBTypeList", _wrap_delete_SBTypeList, METH_O, "delete_SBTypeList(SBTypeList self)"},
	 { "SBTypeList___nonzero__", _wrap_SBTypeList___nonzero__, METH_O, "SBTypeList___nonzero__(SBTypeList self) -> bool"},
	 { "SBTypeList_IsValid", _wrap_SBTypeList_IsValid, METH_O, "SBTypeList_IsValid(SBTypeList self) -> bool"},
	 { "SBTypeList_Append", _wrap_SBTypeList_Append, METH_VARARGS, "SBTypeList_Append(SBTypeList self, SBType type)"},
	 { "SBTypeList_GetTypeAtIndex", _wrap_SBTypeList_GetTypeAtIndex, METH_VARARGS, "SBTypeList_GetTypeAtIndex(SBTypeList self, uint32_t index) -> SBType"},
	 { "SBTypeList_GetSize", _wrap_SBTypeList_GetSize, METH_O, "SBTypeList_GetSize(SBTypeList self) -> uint32_t"},
	 { "SBTypeList_swigregister", SBTypeList_swigregister, METH_O, NULL},
	 { "SBTypeList_swiginit", SBTypeList_swiginit, METH_VARARGS, NULL},
	 { "new_SBTypeCategory", _wrap_new_SBTypeCategory, METH_VARARGS, "\n"
		"SBTypeCategory()\n"
		"new_SBTypeCategory(SBTypeCategory rhs) -> SBTypeCategory\n"
		""},
	 { "delete_SBTypeCategory", _wrap_delete_SBTypeCategory, METH_O, "delete_SBTypeCategory(SBTypeCategory self)"},
	 { "SBTypeCategory___nonzero__", _wrap_SBTypeCategory___nonzero__, METH_O, "SBTypeCategory___nonzero__(SBTypeCategory self) -> bool"},
	 { "SBTypeCategory_IsValid", _wrap_SBTypeCategory_IsValid, METH_O, "SBTypeCategory_IsValid(SBTypeCategory self) -> bool"},
	 { "SBTypeCategory_GetEnabled", _wrap_SBTypeCategory_GetEnabled, METH_O, "SBTypeCategory_GetEnabled(SBTypeCategory self) -> bool"},
	 { "SBTypeCategory_SetEnabled", _wrap_SBTypeCategory_SetEnabled, METH_VARARGS, "SBTypeCategory_SetEnabled(SBTypeCategory self, bool arg2)"},
	 { "SBTypeCategory_GetName", _wrap_SBTypeCategory_GetName, METH_O, "SBTypeCategory_GetName(SBTypeCategory self) -> char const *"},
	 { "SBTypeCategory_GetLanguageAtIndex", _wrap_SBTypeCategory_GetLanguageAtIndex, METH_VARARGS, "SBTypeCategory_GetLanguageAtIndex(SBTypeCategory self, uint32_t idx) -> lldb::LanguageType"},
	 { "SBTypeCategory_GetNumLanguages", _wrap_SBTypeCategory_GetNumLanguages, METH_O, "SBTypeCategory_GetNumLanguages(SBTypeCategory self) -> uint32_t"},
	 { "SBTypeCategory_AddLanguage", _wrap_SBTypeCategory_AddLanguage, METH_VARARGS, "SBTypeCategory_AddLanguage(SBTypeCategory self, lldb::LanguageType language)"},
	 { "SBTypeCategory_GetDescription", _wrap_SBTypeCategory_GetDescription, METH_VARARGS, "SBTypeCategory_GetDescription(SBTypeCategory self, SBStream description, lldb::DescriptionLevel description_level) -> bool"},
	 { "SBTypeCategory_GetNumFormats", _wrap_SBTypeCategory_GetNumFormats, METH_O, "SBTypeCategory_GetNumFormats(SBTypeCategory self) -> uint32_t"},
	 { "SBTypeCategory_GetNumSummaries", _wrap_SBTypeCategory_GetNumSummaries, METH_O, "SBTypeCategory_GetNumSummaries(SBTypeCategory self) -> uint32_t"},
	 { "SBTypeCategory_GetNumFilters", _wrap_SBTypeCategory_GetNumFilters, METH_O, "SBTypeCategory_GetNumFilters(SBTypeCategory self) -> uint32_t"},
	 { "SBTypeCategory_GetNumSynthetics", _wrap_SBTypeCategory_GetNumSynthetics, METH_O, "SBTypeCategory_GetNumSynthetics(SBTypeCategory self) -> uint32_t"},
	 { "SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex", _wrap_SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex, METH_VARARGS, "SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier"},
	 { "SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex", _wrap_SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex, METH_VARARGS, "SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier"},
	 { "SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex", _wrap_SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex, METH_VARARGS, "SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier"},
	 { "SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex", _wrap_SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex, METH_VARARGS, "SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier"},
	 { "SBTypeCategory_GetFilterForType", _wrap_SBTypeCategory_GetFilterForType, METH_VARARGS, "SBTypeCategory_GetFilterForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeFilter"},
	 { "SBTypeCategory_GetFormatForType", _wrap_SBTypeCategory_GetFormatForType, METH_VARARGS, "SBTypeCategory_GetFormatForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeFormat"},
	 { "SBTypeCategory_GetSummaryForType", _wrap_SBTypeCategory_GetSummaryForType, METH_VARARGS, "SBTypeCategory_GetSummaryForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeSummary"},
	 { "SBTypeCategory_GetSyntheticForType", _wrap_SBTypeCategory_GetSyntheticForType, METH_VARARGS, "SBTypeCategory_GetSyntheticForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeSynthetic"},
	 { "SBTypeCategory_GetFilterAtIndex", _wrap_SBTypeCategory_GetFilterAtIndex, METH_VARARGS, "SBTypeCategory_GetFilterAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeFilter"},
	 { "SBTypeCategory_GetFormatAtIndex", _wrap_SBTypeCategory_GetFormatAtIndex, METH_VARARGS, "SBTypeCategory_GetFormatAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeFormat"},
	 { "SBTypeCategory_GetSummaryAtIndex", _wrap_SBTypeCategory_GetSummaryAtIndex, METH_VARARGS, "SBTypeCategory_GetSummaryAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeSummary"},
	 { "SBTypeCategory_GetSyntheticAtIndex", _wrap_SBTypeCategory_GetSyntheticAtIndex, METH_VARARGS, "SBTypeCategory_GetSyntheticAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeSynthetic"},
	 { "SBTypeCategory_AddTypeFormat", _wrap_SBTypeCategory_AddTypeFormat, METH_VARARGS, "SBTypeCategory_AddTypeFormat(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeFormat arg3) -> bool"},
	 { "SBTypeCategory_DeleteTypeFormat", _wrap_SBTypeCategory_DeleteTypeFormat, METH_VARARGS, "SBTypeCategory_DeleteTypeFormat(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool"},
	 { "SBTypeCategory_AddTypeSummary", _wrap_SBTypeCategory_AddTypeSummary, METH_VARARGS, "SBTypeCategory_AddTypeSummary(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeSummary arg3) -> bool"},
	 { "SBTypeCategory_DeleteTypeSummary", _wrap_SBTypeCategory_DeleteTypeSummary, METH_VARARGS, "SBTypeCategory_DeleteTypeSummary(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool"},
	 { "SBTypeCategory_AddTypeFilter", _wrap_SBTypeCategory_AddTypeFilter, METH_VARARGS, "SBTypeCategory_AddTypeFilter(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeFilter arg3) -> bool"},
	 { "SBTypeCategory_DeleteTypeFilter", _wrap_SBTypeCategory_DeleteTypeFilter, METH_VARARGS, "SBTypeCategory_DeleteTypeFilter(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool"},
	 { "SBTypeCategory_AddTypeSynthetic", _wrap_SBTypeCategory_AddTypeSynthetic, METH_VARARGS, "SBTypeCategory_AddTypeSynthetic(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeSynthetic arg3) -> bool"},
	 { "SBTypeCategory_DeleteTypeSynthetic", _wrap_SBTypeCategory_DeleteTypeSynthetic, METH_VARARGS, "SBTypeCategory_DeleteTypeSynthetic(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool"},
	 { "SBTypeCategory___eq__", _wrap_SBTypeCategory___eq__, METH_VARARGS, "SBTypeCategory___eq__(SBTypeCategory self, SBTypeCategory rhs) -> bool"},
	 { "SBTypeCategory___ne__", _wrap_SBTypeCategory___ne__, METH_VARARGS, "SBTypeCategory___ne__(SBTypeCategory self, SBTypeCategory rhs) -> bool"},
	 { "SBTypeCategory___repr__", _wrap_SBTypeCategory___repr__, METH_O, "SBTypeCategory___repr__(SBTypeCategory self) -> std::string"},
	 { "SBTypeCategory_swigregister", SBTypeCategory_swigregister, METH_O, NULL},
	 { "SBTypeCategory_swiginit", SBTypeCategory_swiginit, METH_VARARGS, NULL},
	 { "new_SBTypeEnumMember", _wrap_new_SBTypeEnumMember, METH_VARARGS, "\n"
		"SBTypeEnumMember()\n"
		"new_SBTypeEnumMember(SBTypeEnumMember rhs) -> SBTypeEnumMember\n"
		""},
	 { "delete_SBTypeEnumMember", _wrap_delete_SBTypeEnumMember, METH_O, "delete_SBTypeEnumMember(SBTypeEnumMember self)"},
	 { "SBTypeEnumMember___nonzero__", _wrap_SBTypeEnumMember___nonzero__, METH_O, "SBTypeEnumMember___nonzero__(SBTypeEnumMember self) -> bool"},
	 { "SBTypeEnumMember_IsValid", _wrap_SBTypeEnumMember_IsValid, METH_O, "SBTypeEnumMember_IsValid(SBTypeEnumMember self) -> bool"},
	 { "SBTypeEnumMember_GetValueAsSigned", _wrap_SBTypeEnumMember_GetValueAsSigned, METH_O, "SBTypeEnumMember_GetValueAsSigned(SBTypeEnumMember self) -> int64_t"},
	 { "SBTypeEnumMember_GetValueAsUnsigned", _wrap_SBTypeEnumMember_GetValueAsUnsigned, METH_O, "SBTypeEnumMember_GetValueAsUnsigned(SBTypeEnumMember self) -> uint64_t"},
	 { "SBTypeEnumMember_GetName", _wrap_SBTypeEnumMember_GetName, METH_O, "SBTypeEnumMember_GetName(SBTypeEnumMember self) -> char const *"},
	 { "SBTypeEnumMember_GetType", _wrap_SBTypeEnumMember_GetType, METH_O, "SBTypeEnumMember_GetType(SBTypeEnumMember self) -> SBType"},
	 { "SBTypeEnumMember_GetDescription", _wrap_SBTypeEnumMember_GetDescription, METH_VARARGS, "SBTypeEnumMember_GetDescription(SBTypeEnumMember self, SBStream description, lldb::DescriptionLevel description_level) -> bool"},
	 { "SBTypeEnumMember___repr__", _wrap_SBTypeEnumMember___repr__, METH_O, "SBTypeEnumMember___repr__(SBTypeEnumMember self) -> std::string"},
	 { "SBTypeEnumMember_swigregister", SBTypeEnumMember_swigregister, METH_O, NULL},
	 { "SBTypeEnumMember_swiginit", SBTypeEnumMember_swiginit, METH_VARARGS, NULL},
	 { "new_SBTypeEnumMemberList", _wrap_new_SBTypeEnumMemberList, METH_VARARGS, "\n"
		"SBTypeEnumMemberList()\n"
		"new_SBTypeEnumMemberList(SBTypeEnumMemberList rhs) -> SBTypeEnumMemberList\n"
		""},
	 { "delete_SBTypeEnumMemberList", _wrap_delete_SBTypeEnumMemberList, METH_O, "delete_SBTypeEnumMemberList(SBTypeEnumMemberList self)"},
	 { "SBTypeEnumMemberList___nonzero__", _wrap_SBTypeEnumMemberList___nonzero__, METH_O, "SBTypeEnumMemberList___nonzero__(SBTypeEnumMemberList self) -> bool"},
	 { "SBTypeEnumMemberList_IsValid", _wrap_SBTypeEnumMemberList_IsValid, METH_O, "SBTypeEnumMemberList_IsValid(SBTypeEnumMemberList self) -> bool"},
	 { "SBTypeEnumMemberList_Append", _wrap_SBTypeEnumMemberList_Append, METH_VARARGS, "SBTypeEnumMemberList_Append(SBTypeEnumMemberList self, SBTypeEnumMember entry)"},
	 { "SBTypeEnumMemberList_GetTypeEnumMemberAtIndex", _wrap_SBTypeEnumMemberList_GetTypeEnumMemberAtIndex, METH_VARARGS, "SBTypeEnumMemberList_GetTypeEnumMemberAtIndex(SBTypeEnumMemberList self, uint32_t index) -> SBTypeEnumMember"},
	 { "SBTypeEnumMemberList_GetSize", _wrap_SBTypeEnumMemberList_GetSize, METH_O, "SBTypeEnumMemberList_GetSize(SBTypeEnumMemberList self) -> uint32_t"},
	 { "SBTypeEnumMemberList_swigregister", SBTypeEnumMemberList_swigregister, METH_O, NULL},
	 { "SBTypeEnumMemberList_swiginit", SBTypeEnumMemberList_swiginit, METH_VARARGS, NULL},
	 { "new_SBTypeFilter", _wrap_new_SBTypeFilter, METH_VARARGS, "\n"
		"SBTypeFilter()\n"
		"SBTypeFilter(uint32_t options)\n"
		"new_SBTypeFilter(SBTypeFilter rhs) -> SBTypeFilter\n"
		""},
	 { "delete_SBTypeFilter", _wrap_delete_SBTypeFilter, METH_O, "delete_SBTypeFilter(SBTypeFilter self)"},
	 { "SBTypeFilter___nonzero__", _wrap_SBTypeFilter___nonzero__, METH_O, "SBTypeFilter___nonzero__(SBTypeFilter self) -> bool"},
	 { "SBTypeFilter_IsValid", _wrap_SBTypeFilter_IsValid, METH_O, "SBTypeFilter_IsValid(SBTypeFilter self) -> bool"},
	 { "SBTypeFilter_GetNumberOfExpressionPaths", _wrap_SBTypeFilter_GetNumberOfExpressionPaths, METH_O, "SBTypeFilter_GetNumberOfExpressionPaths(SBTypeFilter self) -> uint32_t"},
	 { "SBTypeFilter_GetExpressionPathAtIndex", _wrap_SBTypeFilter_GetExpressionPathAtIndex, METH_VARARGS, "SBTypeFilter_GetExpressionPathAtIndex(SBTypeFilter self, uint32_t i) -> char const *"},
	 { "SBTypeFilter_ReplaceExpressionPathAtIndex", _wrap_SBTypeFilter_ReplaceExpressionPathAtIndex, METH_VARARGS, "SBTypeFilter_ReplaceExpressionPathAtIndex(SBTypeFilter self, uint32_t i, char const * item) -> bool"},
	 { "SBTypeFilter_AppendExpressionPath", _wrap_SBTypeFilter_AppendExpressionPath, METH_VARARGS, "SBTypeFilter_AppendExpressionPath(SBTypeFilter self, char const * item)"},
	 { "SBTypeFilter_Clear", _wrap_SBTypeFilter_Clear, METH_O, "SBTypeFilter_Clear(SBTypeFilter self)"},
	 { "SBTypeFilter_GetOptions", _wrap_SBTypeFilter_GetOptions, METH_O, "SBTypeFilter_GetOptions(SBTypeFilter self) -> uint32_t"},
	 { "SBTypeFilter_SetOptions", _wrap_SBTypeFilter_SetOptions, METH_VARARGS, "SBTypeFilter_SetOptions(SBTypeFilter self, uint32_t arg2)"},
	 { "SBTypeFilter_GetDescription", _wrap_SBTypeFilter_GetDescription, METH_VARARGS, "SBTypeFilter_GetDescription(SBTypeFilter self, SBStream description, lldb::DescriptionLevel description_level) -> bool"},
	 { "SBTypeFilter_IsEqualTo", _wrap_SBTypeFilter_IsEqualTo, METH_VARARGS, "SBTypeFilter_IsEqualTo(SBTypeFilter self, SBTypeFilter rhs) -> bool"},
	 { "SBTypeFilter___eq__", _wrap_SBTypeFilter___eq__, METH_VARARGS, "SBTypeFilter___eq__(SBTypeFilter self, SBTypeFilter rhs) -> bool"},
	 { "SBTypeFilter___ne__", _wrap_SBTypeFilter___ne__, METH_VARARGS, "SBTypeFilter___ne__(SBTypeFilter self, SBTypeFilter rhs) -> bool"},
	 { "SBTypeFilter___repr__", _wrap_SBTypeFilter___repr__, METH_O, "SBTypeFilter___repr__(SBTypeFilter self) -> std::string"},
	 { "SBTypeFilter_swigregister", SBTypeFilter_swigregister, METH_O, NULL},
	 { "SBTypeFilter_swiginit", SBTypeFilter_swiginit, METH_VARARGS, NULL},
	 { "new_SBTypeFormat", _wrap_new_SBTypeFormat, METH_VARARGS, "\n"
		"SBTypeFormat()\n"
		"SBTypeFormat(lldb::Format format, uint32_t options=0)\n"
		"SBTypeFormat(char const * type, uint32_t options=0)\n"
		"new_SBTypeFormat(SBTypeFormat rhs) -> SBTypeFormat\n"
		""},
	 { "delete_SBTypeFormat", _wrap_delete_SBTypeFormat, METH_O, "delete_SBTypeFormat(SBTypeFormat self)"},
	 { "SBTypeFormat___nonzero__", _wrap_SBTypeFormat___nonzero__, METH_O, "SBTypeFormat___nonzero__(SBTypeFormat self) -> bool"},
	 { "SBTypeFormat_IsValid", _wrap_SBTypeFormat_IsValid, METH_O, "SBTypeFormat_IsValid(SBTypeFormat self) -> bool"},
	 { "SBTypeFormat_GetFormat", _wrap_SBTypeFormat_GetFormat, METH_O, "SBTypeFormat_GetFormat(SBTypeFormat self) -> lldb::Format"},
	 { "SBTypeFormat_GetTypeName", _wrap_SBTypeFormat_GetTypeName, METH_O, "SBTypeFormat_GetTypeName(SBTypeFormat self) -> char const *"},
	 { "SBTypeFormat_GetOptions", _wrap_SBTypeFormat_GetOptions, METH_O, "SBTypeFormat_GetOptions(SBTypeFormat self) -> uint32_t"},
	 { "SBTypeFormat_SetFormat", _wrap_SBTypeFormat_SetFormat, METH_VARARGS, "SBTypeFormat_SetFormat(SBTypeFormat self, lldb::Format arg2)"},
	 { "SBTypeFormat_SetTypeName", _wrap_SBTypeFormat_SetTypeName, METH_VARARGS, "SBTypeFormat_SetTypeName(SBTypeFormat self, char const * arg2)"},
	 { "SBTypeFormat_SetOptions", _wrap_SBTypeFormat_SetOptions, METH_VARARGS, "SBTypeFormat_SetOptions(SBTypeFormat self, uint32_t arg2)"},
	 { "SBTypeFormat_GetDescription", _wrap_SBTypeFormat_GetDescription, METH_VARARGS, "SBTypeFormat_GetDescription(SBTypeFormat self, SBStream description, lldb::DescriptionLevel description_level) -> bool"},
	 { "SBTypeFormat_IsEqualTo", _wrap_SBTypeFormat_IsEqualTo, METH_VARARGS, "SBTypeFormat_IsEqualTo(SBTypeFormat self, SBTypeFormat rhs) -> bool"},
	 { "SBTypeFormat___eq__", _wrap_SBTypeFormat___eq__, METH_VARARGS, "SBTypeFormat___eq__(SBTypeFormat self, SBTypeFormat rhs) -> bool"},
	 { "SBTypeFormat___ne__", _wrap_SBTypeFormat___ne__, METH_VARARGS, "SBTypeFormat___ne__(SBTypeFormat self, SBTypeFormat rhs) -> bool"},
	 { "SBTypeFormat___repr__", _wrap_SBTypeFormat___repr__, METH_O, "SBTypeFormat___repr__(SBTypeFormat self) -> std::string"},
	 { "SBTypeFormat_swigregister", SBTypeFormat_swigregister, METH_O, NULL},
	 { "SBTypeFormat_swiginit", SBTypeFormat_swiginit, METH_VARARGS, NULL},
	 { "new_SBTypeNameSpecifier", _wrap_new_SBTypeNameSpecifier, METH_VARARGS, "\n"
		"SBTypeNameSpecifier()\n"
		"SBTypeNameSpecifier(char const * name, bool is_regex=False)\n"
		"SBTypeNameSpecifier(char const * name, lldb::FormatterMatchType match_type)\n"
		"SBTypeNameSpecifier(SBType type)\n"
		"new_SBTypeNameSpecifier(SBTypeNameSpecifier rhs) -> SBTypeNameSpecifier\n"
		""},
	 { "delete_SBTypeNameSpecifier", _wrap_delete_SBTypeNameSpecifier, METH_O, "delete_SBTypeNameSpecifier(SBTypeNameSpecifier self)"},
	 { "SBTypeNameSpecifier___nonzero__", _wrap_SBTypeNameSpecifier___nonzero__, METH_O, "SBTypeNameSpecifier___nonzero__(SBTypeNameSpecifier self) -> bool"},
	 { "SBTypeNameSpecifier_IsValid", _wrap_SBTypeNameSpecifier_IsValid, METH_O, "SBTypeNameSpecifier_IsValid(SBTypeNameSpecifier self) -> bool"},
	 { "SBTypeNameSpecifier_GetName", _wrap_SBTypeNameSpecifier_GetName, METH_O, "SBTypeNameSpecifier_GetName(SBTypeNameSpecifier self) -> char const *"},
	 { "SBTypeNameSpecifier_GetType", _wrap_SBTypeNameSpecifier_GetType, METH_O, "SBTypeNameSpecifier_GetType(SBTypeNameSpecifier self) -> SBType"},
	 { "SBTypeNameSpecifier_GetMatchType", _wrap_SBTypeNameSpecifier_GetMatchType, METH_O, "SBTypeNameSpecifier_GetMatchType(SBTypeNameSpecifier self) -> lldb::FormatterMatchType"},
	 { "SBTypeNameSpecifier_IsRegex", _wrap_SBTypeNameSpecifier_IsRegex, METH_O, "SBTypeNameSpecifier_IsRegex(SBTypeNameSpecifier self) -> bool"},
	 { "SBTypeNameSpecifier_GetDescription", _wrap_SBTypeNameSpecifier_GetDescription, METH_VARARGS, "SBTypeNameSpecifier_GetDescription(SBTypeNameSpecifier self, SBStream description, lldb::DescriptionLevel description_level) -> bool"},
	 { "SBTypeNameSpecifier_IsEqualTo", _wrap_SBTypeNameSpecifier_IsEqualTo, METH_VARARGS, "SBTypeNameSpecifier_IsEqualTo(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> bool"},
	 { "SBTypeNameSpecifier___eq__", _wrap_SBTypeNameSpecifier___eq__, METH_VARARGS, "SBTypeNameSpecifier___eq__(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> bool"},
	 { "SBTypeNameSpecifier___ne__", _wrap_SBTypeNameSpecifier___ne__, METH_VARARGS, "SBTypeNameSpecifier___ne__(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> bool"},
	 { "SBTypeNameSpecifier___repr__", _wrap_SBTypeNameSpecifier___repr__, METH_O, "SBTypeNameSpecifier___repr__(SBTypeNameSpecifier self) -> std::string"},
	 { "SBTypeNameSpecifier_swigregister", SBTypeNameSpecifier_swigregister, METH_O, NULL},
	 { "SBTypeNameSpecifier_swiginit", SBTypeNameSpecifier_swiginit, METH_VARARGS, NULL},
	 { "new_SBTypeSummaryOptions", _wrap_new_SBTypeSummaryOptions, METH_VARARGS, "\n"
		"SBTypeSummaryOptions()\n"
		"new_SBTypeSummaryOptions(SBTypeSummaryOptions rhs) -> SBTypeSummaryOptions\n"
		""},
	 { "delete_SBTypeSummaryOptions", _wrap_delete_SBTypeSummaryOptions, METH_O, "delete_SBTypeSummaryOptions(SBTypeSummaryOptions self)"},
	 { "SBTypeSummaryOptions___nonzero__", _wrap_SBTypeSummaryOptions___nonzero__, METH_O, "SBTypeSummaryOptions___nonzero__(SBTypeSummaryOptions self) -> bool"},
	 { "SBTypeSummaryOptions_IsValid", _wrap_SBTypeSummaryOptions_IsValid, METH_O, "SBTypeSummaryOptions_IsValid(SBTypeSummaryOptions self) -> bool"},
	 { "SBTypeSummaryOptions_GetLanguage", _wrap_SBTypeSummaryOptions_GetLanguage, METH_O, "SBTypeSummaryOptions_GetLanguage(SBTypeSummaryOptions self) -> lldb::LanguageType"},
	 { "SBTypeSummaryOptions_GetCapping", _wrap_SBTypeSummaryOptions_GetCapping, METH_O, "SBTypeSummaryOptions_GetCapping(SBTypeSummaryOptions self) -> lldb::TypeSummaryCapping"},
	 { "SBTypeSummaryOptions_SetLanguage", _wrap_SBTypeSummaryOptions_SetLanguage, METH_VARARGS, "SBTypeSummaryOptions_SetLanguage(SBTypeSummaryOptions self, lldb::LanguageType arg2)"},
	 { "SBTypeSummaryOptions_SetCapping", _wrap_SBTypeSummaryOptions_SetCapping, METH_VARARGS, "SBTypeSummaryOptions_SetCapping(SBTypeSummaryOptions self, lldb::TypeSummaryCapping arg2)"},
	 { "SBTypeSummaryOptions_swigregister", SBTypeSummaryOptions_swigregister, METH_O, NULL},
	 { "SBTypeSummaryOptions_swiginit", SBTypeSummaryOptions_swiginit, METH_VARARGS, NULL},
	 { "SBTypeSummary_CreateWithSummaryString", _wrap_SBTypeSummary_CreateWithSummaryString, METH_VARARGS, "SBTypeSummary_CreateWithSummaryString(char const * data, uint32_t options=0) -> SBTypeSummary"},
	 { "SBTypeSummary_CreateWithFunctionName", _wrap_SBTypeSummary_CreateWithFunctionName, METH_VARARGS, "SBTypeSummary_CreateWithFunctionName(char const * data, uint32_t options=0) -> SBTypeSummary"},
	 { "SBTypeSummary_CreateWithScriptCode", _wrap_SBTypeSummary_CreateWithScriptCode, METH_VARARGS, "SBTypeSummary_CreateWithScriptCode(char const * data, uint32_t options=0) -> SBTypeSummary"},
	 { "new_SBTypeSummary", _wrap_new_SBTypeSummary, METH_VARARGS, "\n"
		"SBTypeSummary()\n"
		"new_SBTypeSummary(SBTypeSummary rhs) -> SBTypeSummary\n"
		""},
	 { "delete_SBTypeSummary", _wrap_delete_SBTypeSummary, METH_O, "delete_SBTypeSummary(SBTypeSummary self)"},
	 { "SBTypeSummary___nonzero__", _wrap_SBTypeSummary___nonzero__, METH_O, "SBTypeSummary___nonzero__(SBTypeSummary self) -> bool"},
	 { "SBTypeSummary_IsValid", _wrap_SBTypeSummary_IsValid, METH_O, "SBTypeSummary_IsValid(SBTypeSummary self) -> bool"},
	 { "SBTypeSummary_IsFunctionCode", _wrap_SBTypeSummary_IsFunctionCode, METH_O, "SBTypeSummary_IsFunctionCode(SBTypeSummary self) -> bool"},
	 { "SBTypeSummary_IsFunctionName", _wrap_SBTypeSummary_IsFunctionName, METH_O, "SBTypeSummary_IsFunctionName(SBTypeSummary self) -> bool"},
	 { "SBTypeSummary_IsSummaryString", _wrap_SBTypeSummary_IsSummaryString, METH_O, "SBTypeSummary_IsSummaryString(SBTypeSummary self) -> bool"},
	 { "SBTypeSummary_GetData", _wrap_SBTypeSummary_GetData, METH_O, "SBTypeSummary_GetData(SBTypeSummary self) -> char const *"},
	 { "SBTypeSummary_SetSummaryString", _wrap_SBTypeSummary_SetSummaryString, METH_VARARGS, "SBTypeSummary_SetSummaryString(SBTypeSummary self, char const * data)"},
	 { "SBTypeSummary_SetFunctionName", _wrap_SBTypeSummary_SetFunctionName, METH_VARARGS, "SBTypeSummary_SetFunctionName(SBTypeSummary self, char const * data)"},
	 { "SBTypeSummary_SetFunctionCode", _wrap_SBTypeSummary_SetFunctionCode, METH_VARARGS, "SBTypeSummary_SetFunctionCode(SBTypeSummary self, char const * data)"},
	 { "SBTypeSummary_GetPtrMatchDepth", _wrap_SBTypeSummary_GetPtrMatchDepth, METH_O, "SBTypeSummary_GetPtrMatchDepth(SBTypeSummary self) -> uint32_t"},
	 { "SBTypeSummary_SetPtrMatchDepth", _wrap_SBTypeSummary_SetPtrMatchDepth, METH_VARARGS, "SBTypeSummary_SetPtrMatchDepth(SBTypeSummary self, uint32_t ptr_match_depth)"},
	 { "SBTypeSummary_GetOptions", _wrap_SBTypeSummary_GetOptions, METH_O, "SBTypeSummary_GetOptions(SBTypeSummary self) -> uint32_t"},
	 { "SBTypeSummary_SetOptions", _wrap_SBTypeSummary_SetOptions, METH_VARARGS, "SBTypeSummary_SetOptions(SBTypeSummary self, uint32_t arg2)"},
	 { "SBTypeSummary_GetDescription", _wrap_SBTypeSummary_GetDescription, METH_VARARGS, "SBTypeSummary_GetDescription(SBTypeSummary self, SBStream description, lldb::DescriptionLevel description_level) -> bool"},
	 { "SBTypeSummary_DoesPrintValue", _wrap_SBTypeSummary_DoesPrintValue, METH_VARARGS, "SBTypeSummary_DoesPrintValue(SBTypeSummary self, SBValue value) -> bool"},
	 { "SBTypeSummary_IsEqualTo", _wrap_SBTypeSummary_IsEqualTo, METH_VARARGS, "SBTypeSummary_IsEqualTo(SBTypeSummary self, SBTypeSummary rhs) -> bool"},
	 { "SBTypeSummary___eq__", _wrap_SBTypeSummary___eq__, METH_VARARGS, "SBTypeSummary___eq__(SBTypeSummary self, SBTypeSummary rhs) -> bool"},
	 { "SBTypeSummary___ne__", _wrap_SBTypeSummary___ne__, METH_VARARGS, "SBTypeSummary___ne__(SBTypeSummary self, SBTypeSummary rhs) -> bool"},
	 { "SBTypeSummary___repr__", _wrap_SBTypeSummary___repr__, METH_O, "SBTypeSummary___repr__(SBTypeSummary self) -> std::string"},
	 { "SBTypeSummary_swigregister", SBTypeSummary_swigregister, METH_O, NULL},
	 { "SBTypeSummary_swiginit", SBTypeSummary_swiginit, METH_VARARGS, NULL},
	 { "SBTypeSynthetic_CreateWithClassName", _wrap_SBTypeSynthetic_CreateWithClassName, METH_VARARGS, "SBTypeSynthetic_CreateWithClassName(char const * data, uint32_t options=0) -> SBTypeSynthetic"},
	 { "SBTypeSynthetic_CreateWithScriptCode", _wrap_SBTypeSynthetic_CreateWithScriptCode, METH_VARARGS, "SBTypeSynthetic_CreateWithScriptCode(char const * data, uint32_t options=0) -> SBTypeSynthetic"},
	 { "new_SBTypeSynthetic", _wrap_new_SBTypeSynthetic, METH_VARARGS, "\n"
		"SBTypeSynthetic()\n"
		"new_SBTypeSynthetic(SBTypeSynthetic rhs) -> SBTypeSynthetic\n"
		""},
	 { "delete_SBTypeSynthetic", _wrap_delete_SBTypeSynthetic, METH_O, "delete_SBTypeSynthetic(SBTypeSynthetic self)"},
	 { "SBTypeSynthetic___nonzero__", _wrap_SBTypeSynthetic___nonzero__, METH_O, "SBTypeSynthetic___nonzero__(SBTypeSynthetic self) -> bool"},
	 { "SBTypeSynthetic_IsValid", _wrap_SBTypeSynthetic_IsValid, METH_O, "SBTypeSynthetic_IsValid(SBTypeSynthetic self) -> bool"},
	 { "SBTypeSynthetic_IsClassCode", _wrap_SBTypeSynthetic_IsClassCode, METH_O, "SBTypeSynthetic_IsClassCode(SBTypeSynthetic self) -> bool"},
	 { "SBTypeSynthetic_IsClassName", _wrap_SBTypeSynthetic_IsClassName, METH_O, "SBTypeSynthetic_IsClassName(SBTypeSynthetic self) -> bool"},
	 { "SBTypeSynthetic_GetData", _wrap_SBTypeSynthetic_GetData, METH_O, "SBTypeSynthetic_GetData(SBTypeSynthetic self) -> char const *"},
	 { "SBTypeSynthetic_SetClassName", _wrap_SBTypeSynthetic_SetClassName, METH_VARARGS, "SBTypeSynthetic_SetClassName(SBTypeSynthetic self, char const * data)"},
	 { "SBTypeSynthetic_SetClassCode", _wrap_SBTypeSynthetic_SetClassCode, METH_VARARGS, "SBTypeSynthetic_SetClassCode(SBTypeSynthetic self, char const * data)"},
	 { "SBTypeSynthetic_GetOptions", _wrap_SBTypeSynthetic_GetOptions, METH_O, "SBTypeSynthetic_GetOptions(SBTypeSynthetic self) -> uint32_t"},
	 { "SBTypeSynthetic_SetOptions", _wrap_SBTypeSynthetic_SetOptions, METH_VARARGS, "SBTypeSynthetic_SetOptions(SBTypeSynthetic self, uint32_t arg2)"},
	 { "SBTypeSynthetic_GetDescription", _wrap_SBTypeSynthetic_GetDescription, METH_VARARGS, "SBTypeSynthetic_GetDescription(SBTypeSynthetic self, SBStream description, lldb::DescriptionLevel description_level) -> bool"},
	 { "SBTypeSynthetic_IsEqualTo", _wrap_SBTypeSynthetic_IsEqualTo, METH_VARARGS, "SBTypeSynthetic_IsEqualTo(SBTypeSynthetic self, SBTypeSynthetic rhs) -> bool"},
	 { "SBTypeSynthetic___eq__", _wrap_SBTypeSynthetic___eq__, METH_VARARGS, "SBTypeSynthetic___eq__(SBTypeSynthetic self, SBTypeSynthetic rhs) -> bool"},
	 { "SBTypeSynthetic___ne__", _wrap_SBTypeSynthetic___ne__, METH_VARARGS, "SBTypeSynthetic___ne__(SBTypeSynthetic self, SBTypeSynthetic rhs) -> bool"},
	 { "SBTypeSynthetic___repr__", _wrap_SBTypeSynthetic___repr__, METH_O, "SBTypeSynthetic___repr__(SBTypeSynthetic self) -> std::string"},
	 { "SBTypeSynthetic_swigregister", SBTypeSynthetic_swigregister, METH_O, NULL},
	 { "SBTypeSynthetic_swiginit", SBTypeSynthetic_swiginit, METH_VARARGS, NULL},
	 { "new_SBUnixSignals", _wrap_new_SBUnixSignals, METH_VARARGS, "\n"
		"SBUnixSignals()\n"
		"new_SBUnixSignals(SBUnixSignals rhs) -> SBUnixSignals\n"
		""},
	 { "delete_SBUnixSignals", _wrap_delete_SBUnixSignals, METH_O, "delete_SBUnixSignals(SBUnixSignals self)"},
	 { "SBUnixSignals_Clear", _wrap_SBUnixSignals_Clear, METH_O, "SBUnixSignals_Clear(SBUnixSignals self)"},
	 { "SBUnixSignals___nonzero__", _wrap_SBUnixSignals___nonzero__, METH_O, "SBUnixSignals___nonzero__(SBUnixSignals self) -> bool"},
	 { "SBUnixSignals_IsValid", _wrap_SBUnixSignals_IsValid, METH_O, "SBUnixSignals_IsValid(SBUnixSignals self) -> bool"},
	 { "SBUnixSignals_GetSignalAsCString", _wrap_SBUnixSignals_GetSignalAsCString, METH_VARARGS, "SBUnixSignals_GetSignalAsCString(SBUnixSignals self, int32_t signo) -> char const *"},
	 { "SBUnixSignals_GetSignalNumberFromName", _wrap_SBUnixSignals_GetSignalNumberFromName, METH_VARARGS, "SBUnixSignals_GetSignalNumberFromName(SBUnixSignals self, char const * name) -> int32_t"},
	 { "SBUnixSignals_GetShouldSuppress", _wrap_SBUnixSignals_GetShouldSuppress, METH_VARARGS, "SBUnixSignals_GetShouldSuppress(SBUnixSignals self, int32_t signo) -> bool"},
	 { "SBUnixSignals_SetShouldSuppress", _wrap_SBUnixSignals_SetShouldSuppress, METH_VARARGS, "SBUnixSignals_SetShouldSuppress(SBUnixSignals self, int32_t signo, bool value) -> bool"},
	 { "SBUnixSignals_GetShouldStop", _wrap_SBUnixSignals_GetShouldStop, METH_VARARGS, "SBUnixSignals_GetShouldStop(SBUnixSignals self, int32_t signo) -> bool"},
	 { "SBUnixSignals_SetShouldStop", _wrap_SBUnixSignals_SetShouldStop, METH_VARARGS, "SBUnixSignals_SetShouldStop(SBUnixSignals self, int32_t signo, bool value) -> bool"},
	 { "SBUnixSignals_GetShouldNotify", _wrap_SBUnixSignals_GetShouldNotify, METH_VARARGS, "SBUnixSignals_GetShouldNotify(SBUnixSignals self, int32_t signo) -> bool"},
	 { "SBUnixSignals_SetShouldNotify", _wrap_SBUnixSignals_SetShouldNotify, METH_VARARGS, "SBUnixSignals_SetShouldNotify(SBUnixSignals self, int32_t signo, bool value) -> bool"},
	 { "SBUnixSignals_GetNumSignals", _wrap_SBUnixSignals_GetNumSignals, METH_O, "SBUnixSignals_GetNumSignals(SBUnixSignals self) -> int32_t"},
	 { "SBUnixSignals_GetSignalAtIndex", _wrap_SBUnixSignals_GetSignalAtIndex, METH_VARARGS, "SBUnixSignals_GetSignalAtIndex(SBUnixSignals self, int32_t index) -> int32_t"},
	 { "SBUnixSignals_swigregister", SBUnixSignals_swigregister, METH_O, NULL},
	 { "SBUnixSignals_swiginit", SBUnixSignals_swiginit, METH_VARARGS, NULL},
	 { "new_SBValue", _wrap_new_SBValue, METH_VARARGS, "\n"
		"SBValue()\n"
		"new_SBValue(SBValue rhs) -> SBValue\n"
		""},
	 { "delete_SBValue", _wrap_delete_SBValue, METH_O, "delete_SBValue(SBValue self)"},
	 { "SBValue___nonzero__", _wrap_SBValue___nonzero__, METH_O, "SBValue___nonzero__(SBValue self) -> bool"},
	 { "SBValue_IsValid", _wrap_SBValue_IsValid, METH_O, "SBValue_IsValid(SBValue self) -> bool"},
	 { "SBValue_Clear", _wrap_SBValue_Clear, METH_O, "SBValue_Clear(SBValue self)"},
	 { "SBValue_GetError", _wrap_SBValue_GetError, METH_O, "SBValue_GetError(SBValue self) -> SBError"},
	 { "SBValue_GetID", _wrap_SBValue_GetID, METH_O, "SBValue_GetID(SBValue self) -> lldb::user_id_t"},
	 { "SBValue_GetName", _wrap_SBValue_GetName, METH_O, "SBValue_GetName(SBValue self) -> char const *"},
	 { "SBValue_GetTypeName", _wrap_SBValue_GetTypeName, METH_O, "SBValue_GetTypeName(SBValue self) -> char const *"},
	 { "SBValue_GetDisplayTypeName", _wrap_SBValue_GetDisplayTypeName, METH_O, "SBValue_GetDisplayTypeName(SBValue self) -> char const *"},
	 { "SBValue_GetByteSize", _wrap_SBValue_GetByteSize, METH_O, "SBValue_GetByteSize(SBValue self) -> size_t"},
	 { "SBValue_IsInScope", _wrap_SBValue_IsInScope, METH_O, "SBValue_IsInScope(SBValue self) -> bool"},
	 { "SBValue_GetFormat", _wrap_SBValue_GetFormat, METH_O, "SBValue_GetFormat(SBValue self) -> lldb::Format"},
	 { "SBValue_SetFormat", _wrap_SBValue_SetFormat, METH_VARARGS, "SBValue_SetFormat(SBValue self, lldb::Format format)"},
	 { "SBValue_GetValue", _wrap_SBValue_GetValue, METH_O, "SBValue_GetValue(SBValue self) -> char const *"},
	 { "SBValue_GetValueAsSigned", _wrap_SBValue_GetValueAsSigned, METH_VARARGS, "\n"
		"SBValue_GetValueAsSigned(SBValue self, SBError error, int64_t fail_value=0) -> int64_t\n"
		"SBValue_GetValueAsSigned(SBValue self, int64_t fail_value=0) -> int64_t\n"
		""},
	 { "SBValue_GetValueAsUnsigned", _wrap_SBValue_GetValueAsUnsigned, METH_VARARGS, "\n"
		"SBValue_GetValueAsUnsigned(SBValue self, SBError error, uint64_t fail_value=0) -> uint64_t\n"
		"SBValue_GetValueAsUnsigned(SBValue self, uint64_t fail_value=0) -> uint64_t\n"
		""},
	 { "SBValue_GetValueAsAddress", _wrap_SBValue_GetValueAsAddress, METH_O, "\n"
		"SBValue_GetValueAsAddress(SBValue self) -> lldb::addr_t\n"
		"\n"
		"      Return the value as an address.  On failure, LLDB_INVALID_ADDRESS\n"
		"      will be returned.  On architectures like AArch64, where the\n"
		"      top (unaddressable) bits can be used for authentication,\n"
		"      memory tagging, or top byte ignore,  this method will return\n"
		"      the value with those top bits cleared.\n"
		"\n"
		"      GetValueAsUnsigned returns the actual value, with the\n"
		"      authentication/Top Byte Ignore/Memory Tagging Extension bits.\n"
		"\n"
		"      Calling this on a random value which is not a pointer is\n"
		"      incorrect.  Call GetType().IsPointerType() if in doubt.\n"
		"\n"
		"      An SB API program may want to show both the literal byte value\n"
		"      and the address it refers to in memory.  These two SBValue\n"
		"      methods allow SB API writers to behave appropriately for their\n"
		"      interface.\n"
		""},
	 { "SBValue_GetValueType", _wrap_SBValue_GetValueType, METH_O, "SBValue_GetValueType(SBValue self) -> lldb::ValueType"},
	 { "SBValue_GetValueDidChange", _wrap_SBValue_GetValueDidChange, METH_O, "SBValue_GetValueDidChange(SBValue self) -> bool"},
	 { "SBValue_GetSummary", _wrap_SBValue_GetSummary, METH_VARARGS, "\n"
		"SBValue_GetSummary(SBValue self) -> char const\n"
		"SBValue_GetSummary(SBValue self, SBStream stream, SBTypeSummaryOptions options) -> char const *\n"
		""},
	 { "SBValue_GetObjectDescription", _wrap_SBValue_GetObjectDescription, METH_O, "SBValue_GetObjectDescription(SBValue self) -> char const *"},
	 { "SBValue_GetDynamicValue", _wrap_SBValue_GetDynamicValue, METH_VARARGS, "SBValue_GetDynamicValue(SBValue self, lldb::DynamicValueType use_dynamic) -> SBValue"},
	 { "SBValue_GetStaticValue", _wrap_SBValue_GetStaticValue, METH_O, "SBValue_GetStaticValue(SBValue self) -> SBValue"},
	 { "SBValue_GetNonSyntheticValue", _wrap_SBValue_GetNonSyntheticValue, METH_O, "SBValue_GetNonSyntheticValue(SBValue self) -> SBValue"},
	 { "SBValue_GetSyntheticValue", _wrap_SBValue_GetSyntheticValue, METH_O, "SBValue_GetSyntheticValue(SBValue self) -> SBValue"},
	 { "SBValue_GetPreferDynamicValue", _wrap_SBValue_GetPreferDynamicValue, METH_O, "SBValue_GetPreferDynamicValue(SBValue self) -> lldb::DynamicValueType"},
	 { "SBValue_SetPreferDynamicValue", _wrap_SBValue_SetPreferDynamicValue, METH_VARARGS, "SBValue_SetPreferDynamicValue(SBValue self, lldb::DynamicValueType use_dynamic)"},
	 { "SBValue_GetPreferSyntheticValue", _wrap_SBValue_GetPreferSyntheticValue, METH_O, "SBValue_GetPreferSyntheticValue(SBValue self) -> bool"},
	 { "SBValue_SetPreferSyntheticValue", _wrap_SBValue_SetPreferSyntheticValue, METH_VARARGS, "SBValue_SetPreferSyntheticValue(SBValue self, bool use_synthetic)"},
	 { "SBValue_IsDynamic", _wrap_SBValue_IsDynamic, METH_O, "SBValue_IsDynamic(SBValue self) -> bool"},
	 { "SBValue_IsSynthetic", _wrap_SBValue_IsSynthetic, METH_O, "SBValue_IsSynthetic(SBValue self) -> bool"},
	 { "SBValue_IsSyntheticChildrenGenerated", _wrap_SBValue_IsSyntheticChildrenGenerated, METH_O, "SBValue_IsSyntheticChildrenGenerated(SBValue self) -> bool"},
	 { "SBValue_SetSyntheticChildrenGenerated", _wrap_SBValue_SetSyntheticChildrenGenerated, METH_VARARGS, "SBValue_SetSyntheticChildrenGenerated(SBValue self, bool arg2)"},
	 { "SBValue_GetLocation", _wrap_SBValue_GetLocation, METH_O, "SBValue_GetLocation(SBValue self) -> char const *"},
	 { "SBValue_SetValueFromCString", _wrap_SBValue_SetValueFromCString, METH_VARARGS, "\n"
		"SBValue_SetValueFromCString(SBValue self, char const * value_str) -> bool\n"
		"SBValue_SetValueFromCString(SBValue self, char const * value_str, SBError error) -> bool\n"
		""},
	 { "SBValue_GetTypeFormat", _wrap_SBValue_GetTypeFormat, METH_O, "SBValue_GetTypeFormat(SBValue self) -> SBTypeFormat"},
	 { "SBValue_GetTypeSummary", _wrap_SBValue_GetTypeSummary, METH_O, "SBValue_GetTypeSummary(SBValue self) -> SBTypeSummary"},
	 { "SBValue_GetTypeFilter", _wrap_SBValue_GetTypeFilter, METH_O, "SBValue_GetTypeFilter(SBValue self) -> SBTypeFilter"},
	 { "SBValue_GetTypeSynthetic", _wrap_SBValue_GetTypeSynthetic, METH_O, "SBValue_GetTypeSynthetic(SBValue self) -> SBTypeSynthetic"},
	 { "SBValue_CreateChildAtOffset", _wrap_SBValue_CreateChildAtOffset, METH_VARARGS, "SBValue_CreateChildAtOffset(SBValue self, char const * name, uint32_t offset, SBType type) -> SBValue"},
	 { "SBValue_Cast", _wrap_SBValue_Cast, METH_VARARGS, "SBValue_Cast(SBValue self, SBType type) -> SBValue"},
	 { "SBValue_CreateValueFromExpression", _wrap_SBValue_CreateValueFromExpression, METH_VARARGS, "\n"
		"SBValue_CreateValueFromExpression(SBValue self, char const * name, char const * expression) -> SBValue\n"
		"SBValue_CreateValueFromExpression(SBValue self, char const * name, char const * expression, SBExpressionOptions options) -> SBValue\n"
		""},
	 { "SBValue_CreateValueFromAddress", _wrap_SBValue_CreateValueFromAddress, METH_VARARGS, "SBValue_CreateValueFromAddress(SBValue self, char const * name, lldb::addr_t address, SBType type) -> SBValue"},
	 { "SBValue_CreateValueFromData", _wrap_SBValue_CreateValueFromData, METH_VARARGS, "SBValue_CreateValueFromData(SBValue self, char const * name, SBData data, SBType type) -> SBValue"},
	 { "SBValue_CreateBoolValue", _wrap_SBValue_CreateBoolValue, METH_VARARGS, "SBValue_CreateBoolValue(SBValue self, char const * name, bool value) -> SBValue"},
	 { "SBValue_GetChildAtIndex", _wrap_SBValue_GetChildAtIndex, METH_VARARGS, "\n"
		"SBValue_GetChildAtIndex(SBValue self, uint32_t idx) -> SBValue\n"
		"SBValue_GetChildAtIndex(SBValue self, uint32_t idx, lldb::DynamicValueType use_dynamic, bool treat_as_array) -> SBValue\n"
		"\n"
		"    Get a child value by index from a value.\n"
		"\n"
		"    Structs, unions, classes, arrays and pointers have child\n"
		"    values that can be access by index.\n"
		"\n"
		"    Structs and unions access child members using a zero based index\n"
		"    for each child member. For\n"
		"\n"
		"    Classes reserve the first indexes for base classes that have\n"
		"    members (empty base classes are omitted), and all members of the\n"
		"    current class will then follow the base classes.\n"
		"\n"
		"    Pointers differ depending on what they point to. If the pointer\n"
		"    points to a simple type, the child at index zero\n"
		"    is the only child value available, unless synthetic_allowed\n"
		"    is true, in which case the pointer will be used as an array\n"
		"    and can create 'synthetic' child values using positive or\n"
		"    negative indexes. If the pointer points to an aggregate type\n"
		"    (an array, class, union, struct), then the pointee is\n"
		"    transparently skipped and any children are going to be the indexes\n"
		"    of the child values within the aggregate type. For example if\n"
		"    we have a 'Point' type and we have a SBValue that contains a\n"
		"    pointer to a 'Point' type, then the child at index zero will be\n"
		"    the 'x' member, and the child at index 1 will be the 'y' member\n"
		"    (the child at index zero won't be a 'Point' instance).\n"
		"\n"
		"    If you actually need an SBValue that represents the type pointed\n"
		"    to by a SBValue for which GetType().IsPointeeType() returns true,\n"
		"    regardless of the pointee type, you can do that with the SBValue.Dereference\n"
		"    method (or the equivalent deref property).\n"
		"\n"
		"    Arrays have a preset number of children that can be accessed by\n"
		"    index and will returns invalid child values for indexes that are\n"
		"    out of bounds unless the synthetic_allowed is true. In this\n"
		"    case the array can create 'synthetic' child values for indexes\n"
		"    that aren't in the array bounds using positive or negative\n"
		"    indexes.\n"
		"\n"
		"    @param[in] idx\n"
		"        The index of the child value to get\n"
		"\n"
		"    @param[in] use_dynamic\n"
		"        An enumeration that specifies whether to get dynamic values,\n"
		"        and also if the target can be run to figure out the dynamic\n"
		"        type of the child value.\n"
		"\n"
		"    @param[in] synthetic_allowed\n"
		"        If true, then allow child values to be created by index\n"
		"        for pointers and arrays for indexes that normally wouldn't\n"
		"        be allowed.\n"
		"\n"
		"    @return\n"
		"        A new SBValue object that represents the child member value.\n"
		""},
	 { "SBValue_GetIndexOfChildWithName", _wrap_SBValue_GetIndexOfChildWithName, METH_VARARGS, "\n"
		"SBValue_GetIndexOfChildWithName(SBValue self, char const * name) -> uint32_t\n"
		"\n"
		"    Returns the child member index.\n"
		"\n"
		"    Matches children of this object only and will match base classes and\n"
		"    member names if this is a clang typed object.\n"
		"\n"
		"    @param[in] name\n"
		"        The name of the child value to get\n"
		"\n"
		"    @return\n"
		"        An index to the child member value.\n"
		""},
	 { "SBValue_GetChildMemberWithName", _wrap_SBValue_GetChildMemberWithName, METH_VARARGS, "\n"
		"SBValue_GetChildMemberWithName(SBValue self, char const * name) -> SBValue\n"
		"SBValue_GetChildMemberWithName(SBValue self, char const * name, lldb::DynamicValueType use_dynamic) -> SBValue\n"
		"\n"
		"    Returns the child member value.\n"
		"\n"
		"    Matches child members of this object and child members of any base\n"
		"    classes.\n"
		"\n"
		"    @param[in] name\n"
		"        The name of the child value to get\n"
		"\n"
		"    @param[in] use_dynamic\n"
		"        An enumeration that specifies whether to get dynamic values,\n"
		"        and also if the target can be run to figure out the dynamic\n"
		"        type of the child value.\n"
		"\n"
		"    @return\n"
		"        A new SBValue object that represents the child member value.\n"
		""},
	 { "SBValue_GetValueForExpressionPath", _wrap_SBValue_GetValueForExpressionPath, METH_VARARGS, "\n"
		"SBValue_GetValueForExpressionPath(SBValue self, char const * expr_path) -> SBValue\n"
		"Expands nested expressions like .a->b[0].c[1]->d.\n"
		""},
	 { "SBValue_AddressOf", _wrap_SBValue_AddressOf, METH_O, "SBValue_AddressOf(SBValue self) -> SBValue"},
	 { "SBValue_GetLoadAddress", _wrap_SBValue_GetLoadAddress, METH_O, "SBValue_GetLoadAddress(SBValue self) -> lldb::addr_t"},
	 { "SBValue_GetAddress", _wrap_SBValue_GetAddress, METH_O, "SBValue_GetAddress(SBValue self) -> SBAddress"},
	 { "SBValue_GetPointeeData", _wrap_SBValue_GetPointeeData, METH_VARARGS, "\n"
		"SBValue_GetPointeeData(SBValue self, uint32_t item_idx=0, uint32_t item_count=1) -> SBData\n"
		"\n"
		"    Get an SBData wrapping what this SBValue points to.\n"
		"\n"
		"    This method will dereference the current SBValue, if its\n"
		"    data type is a ``T\\*`` or ``T[]``, and extract ``item_count`` elements\n"
		"    of type ``T`` from it, copying their contents in an :py:class:`SBData`.\n"
		"\n"
		"    :param item_idx: The index of the first item to retrieve. For an array\n"
		"        this is equivalent to array[item_idx], for a pointer\n"
		"        to ``\\*(pointer + item_idx)``. In either case, the measurement\n"
		"        unit for item_idx is the ``sizeof(T)`` rather than the byte\n"
		"    :param item_count: How many items should be copied into the output. By default\n"
		"        only one item is copied, but more can be asked for.\n"
		"    :return: The contents of the copied items on success. An empty :py:class:`SBData` otherwise.\n"
		"    :rtype: SBData\n"
		"\n"
		""},
	 { "SBValue_GetData", _wrap_SBValue_GetData, METH_O, "\n"
		"SBValue_GetData(SBValue self) -> SBData\n"
		"\n"
		"    Get an SBData wrapping the contents of this SBValue.\n"
		"\n"
		"    This method will read the contents of this object in memory\n"
		"    and copy them into an SBData for future use.\n"
		"\n"
		"    @return\n"
		"        An SBData with the contents of this SBValue, on success.\n"
		"        An empty SBData otherwise.\n"
		""},
	 { "SBValue_SetData", _wrap_SBValue_SetData, METH_VARARGS, "SBValue_SetData(SBValue self, SBData data, SBError error) -> bool"},
	 { "SBValue_Clone", _wrap_SBValue_Clone, METH_VARARGS, "\n"
		"Creates a copy of the SBValue with a new name and setting the current\n"
		"SBValue as its parent. It should be used when we want to change the\n"
		"name of a SBValue without modifying the actual SBValue itself\n"
		"(e.g. sythetic child provider).\n"
		""},
	 { "SBValue_GetDeclaration", _wrap_SBValue_GetDeclaration, METH_O, "SBValue_GetDeclaration(SBValue self) -> SBDeclaration"},
	 { "SBValue_MightHaveChildren", _wrap_SBValue_MightHaveChildren, METH_O, "\n"
		"Find out if a SBValue might have children.\n"
		"\n"
		"This call is much more efficient than GetNumChildren() as it\n"
		"doesn't need to complete the underlying type. This is designed\n"
		"to be used in a UI environment in order to detect if the\n"
		"disclosure triangle should be displayed or not.\n"
		"\n"
		"This function returns true for class, union, structure,\n"
		"pointers, references, arrays and more. Again, it does so without\n"
		"doing any expensive type completion.\n"
		"\n"
		":rtype: boolean\n"
		":return: \n"
		"        Returns **true** if the SBValue might have children, or\n"
		"   **false** otherwise.\n"
		""},
	 { "SBValue_IsRuntimeSupportValue", _wrap_SBValue_IsRuntimeSupportValue, METH_O, "SBValue_IsRuntimeSupportValue(SBValue self) -> bool"},
	 { "SBValue_GetNumChildren", _wrap_SBValue_GetNumChildren, METH_VARARGS, "\n"
		"*Overload 1:*\n"
		"Return the number of children of this variable. Note that for some\n"
		"variables this operation can be expensive. If possible, prefer calling\n"
		"GetNumChildren(max) with the maximum number of children you are interested\n"
		"in.\n"
		"\n"
		"|\n"
		"\n"
		"*Overload 2:*\n"
		"Return the numer of children of this variable, with a hint that the\n"
		"caller is interested in at most *max* children. Use this function to\n"
		"avoid expensive child computations in some cases. For example, if you know\n"
		"you will only ever display 100 elements, calling GetNumChildren(100) can\n"
		"avoid enumerating all the other children. If the returned value is smaller\n"
		"than *max*, then it represents the true number of children, otherwise it\n"
		"indicates that their number is at least *max*. Do not assume the returned\n"
		"number will always be less than or equal to *max*, as the implementation\n"
		"may choose to return a larger (but still smaller than the actual number of\n"
		"children) value.\n"
		""},
	 { "SBValue_GetOpaqueType", _wrap_SBValue_GetOpaqueType, METH_O, "SBValue_GetOpaqueType(SBValue self) -> void *"},
	 { "SBValue_GetTarget", _wrap_SBValue_GetTarget, METH_O, "SBValue_GetTarget(SBValue self) -> SBTarget"},
	 { "SBValue_GetProcess", _wrap_SBValue_GetProcess, METH_O, "SBValue_GetProcess(SBValue self) -> SBProcess"},
	 { "SBValue_GetThread", _wrap_SBValue_GetThread, METH_O, "SBValue_GetThread(SBValue self) -> SBThread"},
	 { "SBValue_GetFrame", _wrap_SBValue_GetFrame, METH_O, "SBValue_GetFrame(SBValue self) -> SBFrame"},
	 { "SBValue_Dereference", _wrap_SBValue_Dereference, METH_O, "SBValue_Dereference(SBValue self) -> SBValue"},
	 { "SBValue_TypeIsPointerType", _wrap_SBValue_TypeIsPointerType, METH_O, "SBValue_TypeIsPointerType(SBValue self) -> bool"},
	 { "SBValue_GetType", _wrap_SBValue_GetType, METH_O, "SBValue_GetType(SBValue self) -> SBType"},
	 { "SBValue_Persist", _wrap_SBValue_Persist, METH_O, "SBValue_Persist(SBValue self) -> SBValue"},
	 { "SBValue_GetDescription", _wrap_SBValue_GetDescription, METH_VARARGS, "\n"
		"SBValue_GetDescription(SBValue self, SBStream description) -> bool\n"
		"SBValue_GetDescription(SBValue self, SBStream description, lldb::DescriptionLevel description_level) -> bool\n"
		""},
	 { "SBValue_GetExpressionPath", _wrap_SBValue_GetExpressionPath, METH_VARARGS, "\n"
		"SBValue_GetExpressionPath(SBValue self, SBStream description) -> bool\n"
		"SBValue_GetExpressionPath(SBValue self, SBStream description, bool qualify_cxx_base_classes) -> bool\n"
		"Returns an expression path for this value.\n"
		""},
	 { "SBValue_EvaluateExpression", _wrap_SBValue_EvaluateExpression, METH_VARARGS, "\n"
		"SBValue_EvaluateExpression(SBValue self, char const * expr) -> SBValue\n"
		"SBValue_EvaluateExpression(SBValue self, char const * expr, SBExpressionOptions options) -> SBValue\n"
		"SBValue_EvaluateExpression(SBValue self, char const * expr, SBExpressionOptions options, char const * name) -> SBValue\n"
		""},
	 { "SBValue_Watch", _wrap_SBValue_Watch, METH_VARARGS, "\n"
		"SBValue_Watch(SBValue self, bool resolve_location, bool read, bool write, SBError error) -> SBWatchpoint\n"
		"SBValue_Watch(SBValue self, bool resolve_location, bool read, bool write) -> SBWatchpoint\n"
		"\n"
		"    Find and watch a variable.\n"
		"    It returns an SBWatchpoint, which may be invalid.\n"
		""},
	 { "SBValue_WatchPointee", _wrap_SBValue_WatchPointee, METH_VARARGS, "\n"
		"SBValue_WatchPointee(SBValue self, bool resolve_location, bool read, bool write, SBError error) -> SBWatchpoint\n"
		"\n"
		"    Find and watch the location pointed to by a variable.\n"
		"    It returns an SBWatchpoint, which may be invalid.\n"
		""},
	 { "SBValue_GetVTable", _wrap_SBValue_GetVTable, METH_O, "\n"
		"If this value represents a C++ class that has a vtable, return an value\n"
		"that represents the virtual function table.\n"
		"\n"
		"SBValue::GetError() will be in the success state if this value represents\n"
		"a C++ class with a vtable, or an appropriate error describing that the\n"
		"object isn't a C++ class with a vtable or not a C++ class.\n"
		"\n"
		"SBValue::GetName() will be the demangled symbol name for the virtual\n"
		"function table like \"vtable for <classname>\".\n"
		"\n"
		"SBValue::GetValue() will be the address of the first vtable entry if the\n"
		"current SBValue is a class with a vtable, or nothing the current SBValue\n"
		"is not a C++ class or not a C++ class that has a vtable.\n"
		"\n"
		"SBValue::GetValueAtUnsigned(...) will return the address of the first\n"
		"vtable entry.\n"
		"\n"
		"SBValue::GetLoadAddress() will return the address of the vtable pointer\n"
		"found in the parent SBValue.\n"
		"\n"
		"SBValue::GetNumChildren() will return the number of virtual function\n"
		"pointers in the vtable, or zero on error.\n"
		"\n"
		"SBValue::GetChildAtIndex(...) will return each virtual function pointer\n"
		"as a SBValue object.\n"
		"\n"
		"The child SBValue objects will have the following values:\n"
		"\n"
		"SBValue::GetError() will indicate success if the vtable entry was\n"
		"successfully read from memory, or an error if not.\n"
		"\n"
		"SBValue::GetName() will be the vtable function index in the form \"[%u]\"\n"
		"where %u is the index.\n"
		"\n"
		"SBValue::GetValue() will be the virtual function pointer value as a\n"
		"string.\n"
		"\n"
		"SBValue::GetValueAtUnsigned(...) will return the virtual function\n"
		"pointer value.\n"
		"\n"
		"SBValue::GetLoadAddress() will return the address of the virtual function\n"
		"pointer.\n"
		"\n"
		"SBValue::GetNumChildren() returns 0\n"
		""},
	 { "SBValue___repr__", _wrap_SBValue___repr__, METH_O, "SBValue___repr__(SBValue self) -> std::string"},
	 { "SBValue_swigregister", SBValue_swigregister, METH_O, NULL},
	 { "SBValue_swiginit", SBValue_swiginit, METH_VARARGS, NULL},
	 { "new_SBValueList", _wrap_new_SBValueList, METH_VARARGS, "\n"
		"SBValueList()\n"
		"new_SBValueList(SBValueList rhs) -> SBValueList\n"
		""},
	 { "delete_SBValueList", _wrap_delete_SBValueList, METH_O, "delete_SBValueList(SBValueList self)"},
	 { "SBValueList___nonzero__", _wrap_SBValueList___nonzero__, METH_O, "SBValueList___nonzero__(SBValueList self) -> bool"},
	 { "SBValueList_IsValid", _wrap_SBValueList_IsValid, METH_O, "SBValueList_IsValid(SBValueList self) -> bool"},
	 { "SBValueList_Clear", _wrap_SBValueList_Clear, METH_O, "SBValueList_Clear(SBValueList self)"},
	 { "SBValueList_Append", _wrap_SBValueList_Append, METH_VARARGS, "\n"
		"SBValueList_Append(SBValueList self, SBValue val_obj)\n"
		"SBValueList_Append(SBValueList self, SBValueList value_list)\n"
		""},
	 { "SBValueList_GetSize", _wrap_SBValueList_GetSize, METH_O, "SBValueList_GetSize(SBValueList self) -> uint32_t"},
	 { "SBValueList_GetValueAtIndex", _wrap_SBValueList_GetValueAtIndex, METH_VARARGS, "SBValueList_GetValueAtIndex(SBValueList self, uint32_t idx) -> SBValue"},
	 { "SBValueList_GetFirstValueByName", _wrap_SBValueList_GetFirstValueByName, METH_VARARGS, "SBValueList_GetFirstValueByName(SBValueList self, char const * name) -> SBValue"},
	 { "SBValueList_FindValueObjectByUID", _wrap_SBValueList_FindValueObjectByUID, METH_VARARGS, "SBValueList_FindValueObjectByUID(SBValueList self, lldb::user_id_t uid) -> SBValue"},
	 { "SBValueList_GetError", _wrap_SBValueList_GetError, METH_O, "SBValueList_GetError(SBValueList self) -> SBError"},
	 { "SBValueList___str__", _wrap_SBValueList___str__, METH_O, "SBValueList___str__(SBValueList self) -> std::string"},
	 { "SBValueList_swigregister", SBValueList_swigregister, METH_O, NULL},
	 { "SBValueList_swiginit", SBValueList_swiginit, METH_VARARGS, NULL},
	 { "new_SBVariablesOptions", _wrap_new_SBVariablesOptions, METH_VARARGS, "\n"
		"SBVariablesOptions()\n"
		"new_SBVariablesOptions(SBVariablesOptions options) -> SBVariablesOptions\n"
		""},
	 { "delete_SBVariablesOptions", _wrap_delete_SBVariablesOptions, METH_O, "delete_SBVariablesOptions(SBVariablesOptions self)"},
	 { "SBVariablesOptions___nonzero__", _wrap_SBVariablesOptions___nonzero__, METH_O, "SBVariablesOptions___nonzero__(SBVariablesOptions self) -> bool"},
	 { "SBVariablesOptions_IsValid", _wrap_SBVariablesOptions_IsValid, METH_O, "SBVariablesOptions_IsValid(SBVariablesOptions self) -> bool"},
	 { "SBVariablesOptions_GetIncludeArguments", _wrap_SBVariablesOptions_GetIncludeArguments, METH_O, "SBVariablesOptions_GetIncludeArguments(SBVariablesOptions self) -> bool"},
	 { "SBVariablesOptions_SetIncludeArguments", _wrap_SBVariablesOptions_SetIncludeArguments, METH_VARARGS, "SBVariablesOptions_SetIncludeArguments(SBVariablesOptions self, bool arg2)"},
	 { "SBVariablesOptions_GetIncludeRecognizedArguments", _wrap_SBVariablesOptions_GetIncludeRecognizedArguments, METH_VARARGS, "SBVariablesOptions_GetIncludeRecognizedArguments(SBVariablesOptions self, SBTarget arg2) -> bool"},
	 { "SBVariablesOptions_SetIncludeRecognizedArguments", _wrap_SBVariablesOptions_SetIncludeRecognizedArguments, METH_VARARGS, "SBVariablesOptions_SetIncludeRecognizedArguments(SBVariablesOptions self, bool arg2)"},
	 { "SBVariablesOptions_GetIncludeLocals", _wrap_SBVariablesOptions_GetIncludeLocals, METH_O, "SBVariablesOptions_GetIncludeLocals(SBVariablesOptions self) -> bool"},
	 { "SBVariablesOptions_SetIncludeLocals", _wrap_SBVariablesOptions_SetIncludeLocals, METH_VARARGS, "SBVariablesOptions_SetIncludeLocals(SBVariablesOptions self, bool arg2)"},
	 { "SBVariablesOptions_GetIncludeStatics", _wrap_SBVariablesOptions_GetIncludeStatics, METH_O, "SBVariablesOptions_GetIncludeStatics(SBVariablesOptions self) -> bool"},
	 { "SBVariablesOptions_SetIncludeStatics", _wrap_SBVariablesOptions_SetIncludeStatics, METH_VARARGS, "SBVariablesOptions_SetIncludeStatics(SBVariablesOptions self, bool arg2)"},
	 { "SBVariablesOptions_GetInScopeOnly", _wrap_SBVariablesOptions_GetInScopeOnly, METH_O, "SBVariablesOptions_GetInScopeOnly(SBVariablesOptions self) -> bool"},
	 { "SBVariablesOptions_SetInScopeOnly", _wrap_SBVariablesOptions_SetInScopeOnly, METH_VARARGS, "SBVariablesOptions_SetInScopeOnly(SBVariablesOptions self, bool arg2)"},
	 { "SBVariablesOptions_GetIncludeRuntimeSupportValues", _wrap_SBVariablesOptions_GetIncludeRuntimeSupportValues, METH_O, "SBVariablesOptions_GetIncludeRuntimeSupportValues(SBVariablesOptions self) -> bool"},
	 { "SBVariablesOptions_SetIncludeRuntimeSupportValues", _wrap_SBVariablesOptions_SetIncludeRuntimeSupportValues, METH_VARARGS, "SBVariablesOptions_SetIncludeRuntimeSupportValues(SBVariablesOptions self, bool arg2)"},
	 { "SBVariablesOptions_GetUseDynamic", _wrap_SBVariablesOptions_GetUseDynamic, METH_O, "SBVariablesOptions_GetUseDynamic(SBVariablesOptions self) -> lldb::DynamicValueType"},
	 { "SBVariablesOptions_SetUseDynamic", _wrap_SBVariablesOptions_SetUseDynamic, METH_VARARGS, "SBVariablesOptions_SetUseDynamic(SBVariablesOptions self, lldb::DynamicValueType arg2)"},
	 { "SBVariablesOptions_swigregister", SBVariablesOptions_swigregister, METH_O, NULL},
	 { "SBVariablesOptions_swiginit", SBVariablesOptions_swiginit, METH_VARARGS, NULL},
	 { "new_SBWatchpoint", _wrap_new_SBWatchpoint, METH_VARARGS, "\n"
		"SBWatchpoint()\n"
		"new_SBWatchpoint(SBWatchpoint rhs) -> SBWatchpoint\n"
		""},
	 { "delete_SBWatchpoint", _wrap_delete_SBWatchpoint, METH_O, "delete_SBWatchpoint(SBWatchpoint self)"},
	 { "SBWatchpoint___nonzero__", _wrap_SBWatchpoint___nonzero__, METH_O, "SBWatchpoint___nonzero__(SBWatchpoint self) -> bool"},
	 { "SBWatchpoint___eq__", _wrap_SBWatchpoint___eq__, METH_VARARGS, "SBWatchpoint___eq__(SBWatchpoint self, SBWatchpoint rhs) -> bool"},
	 { "SBWatchpoint___ne__", _wrap_SBWatchpoint___ne__, METH_VARARGS, "SBWatchpoint___ne__(SBWatchpoint self, SBWatchpoint rhs) -> bool"},
	 { "SBWatchpoint_IsValid", _wrap_SBWatchpoint_IsValid, METH_O, "SBWatchpoint_IsValid(SBWatchpoint self) -> bool"},
	 { "SBWatchpoint_GetError", _wrap_SBWatchpoint_GetError, METH_O, "SBWatchpoint_GetError(SBWatchpoint self) -> SBError"},
	 { "SBWatchpoint_GetID", _wrap_SBWatchpoint_GetID, METH_O, "SBWatchpoint_GetID(SBWatchpoint self) -> lldb::watch_id_t"},
	 { "SBWatchpoint_GetHardwareIndex", _wrap_SBWatchpoint_GetHardwareIndex, METH_O, "\n"
		"SBWatchpoint_GetHardwareIndex(SBWatchpoint self) -> int32_t\n"
		"\n"
		"    Deprecated.  Previously: Return the hardware index of the \n"
		"    watchpoint register.  Now: -1 is always returned.\n"
		""},
	 { "SBWatchpoint_GetWatchAddress", _wrap_SBWatchpoint_GetWatchAddress, METH_O, "SBWatchpoint_GetWatchAddress(SBWatchpoint self) -> lldb::addr_t"},
	 { "SBWatchpoint_GetWatchSize", _wrap_SBWatchpoint_GetWatchSize, METH_O, "SBWatchpoint_GetWatchSize(SBWatchpoint self) -> size_t"},
	 { "SBWatchpoint_SetEnabled", _wrap_SBWatchpoint_SetEnabled, METH_VARARGS, "SBWatchpoint_SetEnabled(SBWatchpoint self, bool enabled)"},
	 { "SBWatchpoint_IsEnabled", _wrap_SBWatchpoint_IsEnabled, METH_O, "SBWatchpoint_IsEnabled(SBWatchpoint self) -> bool"},
	 { "SBWatchpoint_GetHitCount", _wrap_SBWatchpoint_GetHitCount, METH_O, "SBWatchpoint_GetHitCount(SBWatchpoint self) -> uint32_t"},
	 { "SBWatchpoint_GetIgnoreCount", _wrap_SBWatchpoint_GetIgnoreCount, METH_O, "SBWatchpoint_GetIgnoreCount(SBWatchpoint self) -> uint32_t"},
	 { "SBWatchpoint_SetIgnoreCount", _wrap_SBWatchpoint_SetIgnoreCount, METH_VARARGS, "SBWatchpoint_SetIgnoreCount(SBWatchpoint self, uint32_t n)"},
	 { "SBWatchpoint_GetCondition", _wrap_SBWatchpoint_GetCondition, METH_O, "\n"
		"SBWatchpoint_GetCondition(SBWatchpoint self) -> char const *\n"
		"\n"
		"    Get the condition expression for the watchpoint.\n"
		""},
	 { "SBWatchpoint_SetCondition", _wrap_SBWatchpoint_SetCondition, METH_VARARGS, "\n"
		"SBWatchpoint_SetCondition(SBWatchpoint self, char const * condition)\n"
		"\n"
		"    The watchpoint stops only if the condition expression evaluates to true.\n"
		""},
	 { "SBWatchpoint_GetDescription", _wrap_SBWatchpoint_GetDescription, METH_VARARGS, "SBWatchpoint_GetDescription(SBWatchpoint self, SBStream description, lldb::DescriptionLevel level) -> bool"},
	 { "SBWatchpoint_Clear", _wrap_SBWatchpoint_Clear, METH_O, "SBWatchpoint_Clear(SBWatchpoint self)"},
	 { "SBWatchpoint_EventIsWatchpointEvent", _wrap_SBWatchpoint_EventIsWatchpointEvent, METH_O, "SBWatchpoint_EventIsWatchpointEvent(SBEvent event) -> bool"},
	 { "SBWatchpoint_GetWatchpointEventTypeFromEvent", _wrap_SBWatchpoint_GetWatchpointEventTypeFromEvent, METH_O, "SBWatchpoint_GetWatchpointEventTypeFromEvent(SBEvent event) -> lldb::WatchpointEventType"},
	 { "SBWatchpoint_GetWatchpointFromEvent", _wrap_SBWatchpoint_GetWatchpointFromEvent, METH_O, "SBWatchpoint_GetWatchpointFromEvent(SBEvent event) -> SBWatchpoint"},
	 { "SBWatchpoint_GetType", _wrap_SBWatchpoint_GetType, METH_O, "\n"
		"SBWatchpoint_GetType(SBWatchpoint self) -> SBType\n"
		"\n"
		"    Returns the type recorded when the watchpoint was created. For variable\n"
		"    watchpoints it is the type of the watched variable. For expression\n"
		"    watchpoints it is the type of the provided expression.\n"
		""},
	 { "SBWatchpoint_GetWatchValueKind", _wrap_SBWatchpoint_GetWatchValueKind, METH_O, "\n"
		"SBWatchpoint_GetWatchValueKind(SBWatchpoint self) -> lldb::WatchpointValueKind\n"
		"\n"
		"    Returns the kind of value that was watched when the watchpoint was created.\n"
		"    Returns one of the following eWatchPointValueKindVariable,\n"
		"    eWatchPointValueKindExpression, eWatchPointValueKindInvalid.\n"
		"\n"
		""},
	 { "SBWatchpoint_GetWatchSpec", _wrap_SBWatchpoint_GetWatchSpec, METH_O, "\n"
		"SBWatchpoint_GetWatchSpec(SBWatchpoint self) -> char const *\n"
		"\n"
		"    Get the spec for the watchpoint. For variable watchpoints this is the name\n"
		"    of the variable. For expression watchpoints it is empty\n"
		"    (may change in the future).\n"
		""},
	 { "SBWatchpoint_IsWatchingReads", _wrap_SBWatchpoint_IsWatchingReads, METH_O, "\n"
		"SBWatchpoint_IsWatchingReads(SBWatchpoint self) -> bool\n"
		"\n"
		"    Returns true if the watchpoint is watching reads. Returns false otherwise.\n"
		""},
	 { "SBWatchpoint_IsWatchingWrites", _wrap_SBWatchpoint_IsWatchingWrites, METH_O, "\n"
		"SBWatchpoint_IsWatchingWrites(SBWatchpoint self) -> bool\n"
		"\n"
		"    Returns true if the watchpoint is watching writes. Returns false otherwise.\n"
		""},
	 { "SBWatchpoint___repr__", _wrap_SBWatchpoint___repr__, METH_O, "SBWatchpoint___repr__(SBWatchpoint self) -> std::string"},
	 { "SBWatchpoint_swigregister", SBWatchpoint_swigregister, METH_O, NULL},
	 { "SBWatchpoint_swiginit", SBWatchpoint_swiginit, METH_VARARGS, NULL},
	 { "new_SBWatchpointOptions", _wrap_new_SBWatchpointOptions, METH_VARARGS, "\n"
		"SBWatchpointOptions()\n"
		"new_SBWatchpointOptions(SBWatchpointOptions rhs) -> SBWatchpointOptions\n"
		""},
	 { "delete_SBWatchpointOptions", _wrap_delete_SBWatchpointOptions, METH_O, "delete_SBWatchpointOptions(SBWatchpointOptions self)"},
	 { "SBWatchpointOptions_SetWatchpointTypeRead", _wrap_SBWatchpointOptions_SetWatchpointTypeRead, METH_VARARGS, "\n"
		"SBWatchpointOptions_SetWatchpointTypeRead(SBWatchpointOptions self, bool read)\n"
		"Sets whether the watchpoint should stop on read accesses.\n"
		""},
	 { "SBWatchpointOptions_GetWatchpointTypeRead", _wrap_SBWatchpointOptions_GetWatchpointTypeRead, METH_O, "\n"
		"SBWatchpointOptions_GetWatchpointTypeRead(SBWatchpointOptions self) -> bool\n"
		"Gets whether the watchpoint should stop on read accesses.\n"
		""},
	 { "SBWatchpointOptions_SetWatchpointTypeWrite", _wrap_SBWatchpointOptions_SetWatchpointTypeWrite, METH_VARARGS, "\n"
		"SBWatchpointOptions_SetWatchpointTypeWrite(SBWatchpointOptions self, lldb::WatchpointWriteType write_type)\n"
		"Sets whether the watchpoint should stop on write accesses. eWatchpointWriteTypeOnModify is the most commonly useful mode, where lldb will stop when the watched value has changed. eWatchpointWriteTypeAlways will stop on any write to the watched region, even if it's the value is the same.\n"
		""},
	 { "SBWatchpointOptions_GetWatchpointTypeWrite", _wrap_SBWatchpointOptions_GetWatchpointTypeWrite, METH_O, "\n"
		"SBWatchpointOptions_GetWatchpointTypeWrite(SBWatchpointOptions self) -> lldb::WatchpointWriteType\n"
		"Gets whether the watchpoint should stop on write accesses, returning WatchpointWriteType to indicate the type of write watching that is enabled, or eWatchpointWriteTypeDisabled.\n"
		""},
	 { "SBWatchpointOptions_swigregister", SBWatchpointOptions_swigregister, METH_O, NULL},
	 { "SBWatchpointOptions_swiginit", SBWatchpointOptions_swiginit, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void__p_void = {"_p_f_p_void__p_void", "lldb::thread_func_t|void *(*)(void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__void_size_t__void = {"_p_f_p_void_p_q_const__void_size_t__void", "lldb::SBCommunication::ReadThreadBytesReceived|void (*)(void *,void const *,size_t)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int32_t *|int_fast16_t *|int_fast32_t *|int_least32_t *|intptr_t *|lldb::break_id_t *|lldb::callback_token_t *|lldb::file_t *|lldb::pipe_t *|lldb::socket_t *|lldb::watch_id_t *|int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__ConnectionStatus = {"_p_lldb__ConnectionStatus", "lldb::ConnectionStatus *|enum lldb::ConnectionStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBAddress = {"_p_lldb__SBAddress", "lldb::SBAddress *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBAddressRange = {"_p_lldb__SBAddressRange", "lldb::SBAddressRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBAddressRangeList = {"_p_lldb__SBAddressRangeList", "lldb::SBAddressRangeList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBAttachInfo = {"_p_lldb__SBAttachInfo", "lldb::SBAttachInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBBlock = {"_p_lldb__SBBlock", "lldb::SBBlock *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBBreakpoint = {"_p_lldb__SBBreakpoint", "lldb::SBBreakpoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBBreakpointList = {"_p_lldb__SBBreakpointList", "lldb::SBBreakpointList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBBreakpointLocation = {"_p_lldb__SBBreakpointLocation", "lldb::SBBreakpointLocation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBBreakpointName = {"_p_lldb__SBBreakpointName", "lldb::SBBreakpointName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBBroadcaster = {"_p_lldb__SBBroadcaster", "lldb::SBBroadcaster *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBCommandInterpreter = {"_p_lldb__SBCommandInterpreter", "lldb::SBCommandInterpreter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBCommandInterpreterRunOptions = {"_p_lldb__SBCommandInterpreterRunOptions", "lldb::SBCommandInterpreterRunOptions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBCommandReturnObject = {"_p_lldb__SBCommandReturnObject", "lldb::SBCommandReturnObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBCommunication = {"_p_lldb__SBCommunication", "lldb::SBCommunication *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBCompileUnit = {"_p_lldb__SBCompileUnit", "lldb::SBCompileUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBData = {"_p_lldb__SBData", "lldb::SBData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBDebugger = {"_p_lldb__SBDebugger", "lldb::SBDebugger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBDeclaration = {"_p_lldb__SBDeclaration", "lldb::SBDeclaration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBEnvironment = {"_p_lldb__SBEnvironment", "lldb::SBEnvironment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBError = {"_p_lldb__SBError", "lldb::SBError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBEvent = {"_p_lldb__SBEvent", "lldb::SBEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBExecutionContext = {"_p_lldb__SBExecutionContext", "lldb::SBExecutionContext *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBExpressionOptions = {"_p_lldb__SBExpressionOptions", "lldb::SBExpressionOptions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBFile = {"_p_lldb__SBFile", "lldb::SBFile *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBFileSpec = {"_p_lldb__SBFileSpec", "lldb::SBFileSpec *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBFileSpecList = {"_p_lldb__SBFileSpecList", "lldb::SBFileSpecList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBFormat = {"_p_lldb__SBFormat", "lldb::SBFormat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBFrame = {"_p_lldb__SBFrame", "lldb::SBFrame *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBFrameList = {"_p_lldb__SBFrameList", "lldb::SBFrameList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBFunction = {"_p_lldb__SBFunction", "lldb::SBFunction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBHostOS = {"_p_lldb__SBHostOS", "lldb::SBHostOS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBInstruction = {"_p_lldb__SBInstruction", "lldb::SBInstruction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBInstructionList = {"_p_lldb__SBInstructionList", "lldb::SBInstructionList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBLanguageRuntime = {"_p_lldb__SBLanguageRuntime", "lldb::SBLanguageRuntime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBLaunchInfo = {"_p_lldb__SBLaunchInfo", "lldb::SBLaunchInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBLineEntry = {"_p_lldb__SBLineEntry", "lldb::SBLineEntry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBListener = {"_p_lldb__SBListener", "lldb::SBListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBMemoryRegionInfo = {"_p_lldb__SBMemoryRegionInfo", "lldb::SBMemoryRegionInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBMemoryRegionInfoList = {"_p_lldb__SBMemoryRegionInfoList", "lldb::SBMemoryRegionInfoList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBModule = {"_p_lldb__SBModule", "lldb::SBModule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBModuleSpec = {"_p_lldb__SBModuleSpec", "lldb::SBModuleSpec *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBModuleSpecList = {"_p_lldb__SBModuleSpecList", "lldb::SBModuleSpecList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBMutex = {"_p_lldb__SBMutex", "lldb::SBMutex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBPlatform = {"_p_lldb__SBPlatform", "lldb::SBPlatform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBPlatformConnectOptions = {"_p_lldb__SBPlatformConnectOptions", "lldb::SBPlatformConnectOptions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBPlatformShellCommand = {"_p_lldb__SBPlatformShellCommand", "lldb::SBPlatformShellCommand *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBProcess = {"_p_lldb__SBProcess", "lldb::SBProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBProcessInfo = {"_p_lldb__SBProcessInfo", "lldb::SBProcessInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBProcessInfoList = {"_p_lldb__SBProcessInfoList", "lldb::SBProcessInfoList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBProgress = {"_p_lldb__SBProgress", "lldb::SBProgress *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBQueue = {"_p_lldb__SBQueue", "lldb::SBQueue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBQueueItem = {"_p_lldb__SBQueueItem", "lldb::SBQueueItem *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBReproducer = {"_p_lldb__SBReproducer", "lldb::SBReproducer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBSaveCoreOptions = {"_p_lldb__SBSaveCoreOptions", "lldb::SBSaveCoreOptions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBScriptObject = {"_p_lldb__SBScriptObject", "lldb::SBScriptObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBSection = {"_p_lldb__SBSection", "lldb::SBSection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBSourceManager = {"_p_lldb__SBSourceManager", "lldb::SBSourceManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBStatisticsOptions = {"_p_lldb__SBStatisticsOptions", "lldb::SBStatisticsOptions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBStream = {"_p_lldb__SBStream", "lldb::SBStream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBStringList = {"_p_lldb__SBStringList", "lldb::SBStringList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBStructuredData = {"_p_lldb__SBStructuredData", "lldb::SBStructuredData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBSymbol = {"_p_lldb__SBSymbol", "lldb::SBSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBSymbolContext = {"_p_lldb__SBSymbolContext", "lldb::SBSymbolContext *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBSymbolContextList = {"_p_lldb__SBSymbolContextList", "lldb::SBSymbolContextList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBTarget = {"_p_lldb__SBTarget", "lldb::SBTarget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBThread = {"_p_lldb__SBThread", "lldb::SBThread *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBThreadCollection = {"_p_lldb__SBThreadCollection", "lldb::SBThreadCollection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBThreadPlan = {"_p_lldb__SBThreadPlan", "lldb::SBThreadPlan *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBTrace = {"_p_lldb__SBTrace", "lldb::SBTrace *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBTraceCursor = {"_p_lldb__SBTraceCursor", "lldb::SBTraceCursor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBType = {"_p_lldb__SBType", "lldb::SBType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBTypeCategory = {"_p_lldb__SBTypeCategory", "lldb::SBTypeCategory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBTypeEnumMember = {"_p_lldb__SBTypeEnumMember", "lldb::SBTypeEnumMember *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBTypeEnumMemberList = {"_p_lldb__SBTypeEnumMemberList", "lldb::SBTypeEnumMemberList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBTypeFilter = {"_p_lldb__SBTypeFilter", "lldb::SBTypeFilter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBTypeFormat = {"_p_lldb__SBTypeFormat", "lldb::SBTypeFormat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBTypeList = {"_p_lldb__SBTypeList", "lldb::SBTypeList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBTypeMember = {"_p_lldb__SBTypeMember", "lldb::SBTypeMember *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBTypeMemberFunction = {"_p_lldb__SBTypeMemberFunction", "lldb::SBTypeMemberFunction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBTypeNameSpecifier = {"_p_lldb__SBTypeNameSpecifier", "lldb::SBTypeNameSpecifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBTypeStaticField = {"_p_lldb__SBTypeStaticField", "lldb::SBTypeStaticField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBTypeSummary = {"_p_lldb__SBTypeSummary", "lldb::SBTypeSummary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBTypeSummaryOptions = {"_p_lldb__SBTypeSummaryOptions", "lldb::SBTypeSummaryOptions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBTypeSynthetic = {"_p_lldb__SBTypeSynthetic", "lldb::SBTypeSynthetic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBUnixSignals = {"_p_lldb__SBUnixSignals", "lldb::SBUnixSignals *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBValue = {"_p_lldb__SBValue", "lldb::SBValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBValueList = {"_p_lldb__SBValueList", "lldb::SBValueList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBVariablesOptions = {"_p_lldb__SBVariablesOptions", "lldb::SBVariablesOptions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBWatchpoint = {"_p_lldb__SBWatchpoint", "lldb::SBWatchpoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_lldb__SBWatchpointOptions = {"_p_lldb__SBWatchpointOptions", "lldb::SBWatchpointOptions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_double = {"_p_long_double", "long double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_long = {"_p_long_long", "int64_t *|int_fast64_t *|int_least64_t *|intmax_t *|long long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_void = {"_p_p_void", "lldb::thread_result_t *|void **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_pthread_rwlock_t = {"_p_pthread_rwlock_t", "lldb::rwlock_t *|pthread_rwlock_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_pthread_t = {"_p_pthread_t", "lldb::thread_t *|pthread_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "int16_t *|int_least16_t *|short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "int8_t *|int_fast8_t *|int_least8_t *|signed char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ABI_t = {"_p_std__shared_ptrT_lldb_private__ABI_t", "lldb::ABISP *|std::shared_ptr< lldb_private::ABI > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Baton_t = {"_p_std__shared_ptrT_lldb_private__Baton_t", "lldb::BatonSP *|std::shared_ptr< lldb_private::Baton > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Block_t = {"_p_std__shared_ptrT_lldb_private__Block_t", "lldb::BlockSP *|std::shared_ptr< lldb_private::Block > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__BreakpointLocation_t = {"_p_std__shared_ptrT_lldb_private__BreakpointLocation_t", "lldb::BreakpointLocationSP *|std::shared_ptr< lldb_private::BreakpointLocation > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__BreakpointPrecondition_t = {"_p_std__shared_ptrT_lldb_private__BreakpointPrecondition_t", "lldb::BreakpointPreconditionSP *|std::shared_ptr< lldb_private::BreakpointPrecondition > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__BreakpointResolver_t = {"_p_std__shared_ptrT_lldb_private__BreakpointResolver_t", "lldb::BreakpointResolverSP *|std::shared_ptr< lldb_private::BreakpointResolver > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__BreakpointSite_t = {"_p_std__shared_ptrT_lldb_private__BreakpointSite_t", "lldb::BreakpointSiteSP *|std::shared_ptr< lldb_private::BreakpointSite > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Breakpoint_t = {"_p_std__shared_ptrT_lldb_private__Breakpoint_t", "lldb::BreakpointSP *|std::shared_ptr< lldb_private::Breakpoint > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__BroadcasterManager_t = {"_p_std__shared_ptrT_lldb_private__BroadcasterManager_t", "lldb::BroadcasterManagerSP *|std::shared_ptr< lldb_private::BroadcasterManager > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Broadcaster_t = {"_p_std__shared_ptrT_lldb_private__Broadcaster_t", "lldb::BroadcasterSP *|std::shared_ptr< lldb_private::Broadcaster > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__CommandObject_t = {"_p_std__shared_ptrT_lldb_private__CommandObject_t", "lldb::CommandObjectSP *|std::shared_ptr< lldb_private::CommandObject > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__CompileUnit_t = {"_p_std__shared_ptrT_lldb_private__CompileUnit_t", "lldb::CompUnitSP *|std::shared_ptr< lldb_private::CompileUnit > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Connection_t = {"_p_std__shared_ptrT_lldb_private__Connection_t", "lldb::ConnectionSP *|std::shared_ptr< lldb_private::Connection > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__DataBuffer_t = {"_p_std__shared_ptrT_lldb_private__DataBuffer_t", "lldb::DataBufferSP *|std::shared_ptr< lldb_private::DataBuffer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__DataExtractor_t = {"_p_std__shared_ptrT_lldb_private__DataExtractor_t", "lldb::DataExtractorSP *|std::shared_ptr< lldb_private::DataExtractor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Debugger_t = {"_p_std__shared_ptrT_lldb_private__Debugger_t", "lldb::DebuggerSP *|std::shared_ptr< lldb_private::Debugger > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Disassembler_t = {"_p_std__shared_ptrT_lldb_private__Disassembler_t", "lldb::DisassemblerSP *|std::shared_ptr< lldb_private::Disassembler > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__EventDataStructuredData_t = {"_p_std__shared_ptrT_lldb_private__EventDataStructuredData_t", "lldb::EventDataStructuredDataSP *|std::shared_ptr< lldb_private::EventDataStructuredData > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__EventData_t = {"_p_std__shared_ptrT_lldb_private__EventData_t", "lldb::EventDataSP *|std::shared_ptr< lldb_private::EventData > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Event_t = {"_p_std__shared_ptrT_lldb_private__Event_t", "lldb::EventSP *|std::shared_ptr< lldb_private::Event > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ExecutionContextRef_t = {"_p_std__shared_ptrT_lldb_private__ExecutionContextRef_t", "lldb::ExecutionContextRefSP *|std::shared_ptr< lldb_private::ExecutionContextRef > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ExpressionVariable_t = {"_p_std__shared_ptrT_lldb_private__ExpressionVariable_t", "lldb::ExpressionVariableSP *|std::shared_ptr< lldb_private::ExpressionVariable > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__File_t = {"_p_std__shared_ptrT_lldb_private__File_t", "lldb::FileSP *|std::shared_ptr< lldb_private::File > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__FormatEntity__Entry_t = {"_p_std__shared_ptrT_lldb_private__FormatEntity__Entry_t", "lldb::FormatEntrySP *|std::shared_ptr< lldb_private::FormatEntity::Entry > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__FuncUnwinders_t = {"_p_std__shared_ptrT_lldb_private__FuncUnwinders_t", "lldb::FuncUnwindersSP *|std::shared_ptr< lldb_private::FuncUnwinders > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Function_t = {"_p_std__shared_ptrT_lldb_private__Function_t", "lldb::FunctionSP *|std::shared_ptr< lldb_private::Function > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__IOHandler_t = {"_p_std__shared_ptrT_lldb_private__IOHandler_t", "lldb::IOHandlerSP *|std::shared_ptr< lldb_private::IOHandler > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__IOObject_t = {"_p_std__shared_ptrT_lldb_private__IOObject_t", "lldb::IOObjectSP *|std::shared_ptr< lldb_private::IOObject > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__IRExecutionUnit_t = {"_p_std__shared_ptrT_lldb_private__IRExecutionUnit_t", "lldb::IRExecutionUnitSP *|std::shared_ptr< lldb_private::IRExecutionUnit > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t = {"_p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t", "lldb::InlineFunctionInfoSP *|std::shared_ptr< lldb_private::InlineFunctionInfo > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Instruction_t = {"_p_std__shared_ptrT_lldb_private__Instruction_t", "lldb::InstructionSP *|std::shared_ptr< lldb_private::Instruction > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t = {"_p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t", "lldb::InstrumentationRuntimeSP *|std::shared_ptr< lldb_private::InstrumentationRuntime > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__JITLoader_t = {"_p_std__shared_ptrT_lldb_private__JITLoader_t", "lldb::JITLoaderSP *|std::shared_ptr< lldb_private::JITLoader > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__LanguageRuntime_t = {"_p_std__shared_ptrT_lldb_private__LanguageRuntime_t", "lldb::LanguageRuntimeSP *|std::shared_ptr< lldb_private::LanguageRuntime > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Listener_t = {"_p_std__shared_ptrT_lldb_private__Listener_t", "lldb::ListenerSP *|std::shared_ptr< lldb_private::Listener > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__LockableStreamFile_t = {"_p_std__shared_ptrT_lldb_private__LockableStreamFile_t", "lldb::LockableStreamFileSP *|std::shared_ptr< lldb_private::LockableStreamFile > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__MemoryHistory_t = {"_p_std__shared_ptrT_lldb_private__MemoryHistory_t", "lldb::MemoryHistorySP *|std::shared_ptr< lldb_private::MemoryHistory > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t = {"_p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t", "lldb::MemoryRegionInfoSP *|std::shared_ptr< lldb_private::MemoryRegionInfo > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Module_t = {"_p_std__shared_ptrT_lldb_private__Module_t", "lldb::ModuleSP *|std::shared_ptr< lldb_private::Module > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ObjectContainer_t = {"_p_std__shared_ptrT_lldb_private__ObjectContainer_t", "lldb::ObjectContainerSP *|std::shared_ptr< lldb_private::ObjectContainer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t = {"_p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t", "lldb::ObjectFileJITDelegateSP *|std::shared_ptr< lldb_private::ObjectFileJITDelegate > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ObjectFile_t = {"_p_std__shared_ptrT_lldb_private__ObjectFile_t", "lldb::ObjectFileSP *|std::shared_ptr< lldb_private::ObjectFile > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__OperatingSystemInterface_t = {"_p_std__shared_ptrT_lldb_private__OperatingSystemInterface_t", "lldb::OperatingSystemInterfaceSP *|std::shared_ptr< lldb_private::OperatingSystemInterface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__OptionValueProperties_t = {"_p_std__shared_ptrT_lldb_private__OptionValueProperties_t", "lldb::OptionValuePropertiesSP *|std::shared_ptr< lldb_private::OptionValueProperties > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__OptionValue_t = {"_p_std__shared_ptrT_lldb_private__OptionValue_t", "lldb::OptionValueSP *|std::shared_ptr< lldb_private::OptionValue > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Platform_t = {"_p_std__shared_ptrT_lldb_private__Platform_t", "lldb::PlatformSP *|std::shared_ptr< lldb_private::Platform > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t = {"_p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t", "lldb::ProcessAttachInfoSP *|std::shared_ptr< lldb_private::ProcessAttachInfo > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ProcessLaunchInfo_t = {"_p_std__shared_ptrT_lldb_private__ProcessLaunchInfo_t", "lldb::ProcessLaunchInfoSP *|std::shared_ptr< lldb_private::ProcessLaunchInfo > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Process_t = {"_p_std__shared_ptrT_lldb_private__Process_t", "lldb::ProcessSP *|std::shared_ptr< lldb_private::Process > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__QueueItem_t = {"_p_std__shared_ptrT_lldb_private__QueueItem_t", "lldb::QueueItemSP *|std::shared_ptr< lldb_private::QueueItem > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Queue_t = {"_p_std__shared_ptrT_lldb_private__Queue_t", "lldb::QueueSP *|std::shared_ptr< lldb_private::Queue > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__REPL_t = {"_p_std__shared_ptrT_lldb_private__REPL_t", "lldb::REPLSP *|std::shared_ptr< lldb_private::REPL > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t = {"_p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t", "lldb::RecognizedStackFrameSP *|std::shared_ptr< lldb_private::RecognizedStackFrame > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t = {"_p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t", "lldb::RegisterCheckpointSP *|std::shared_ptr< lldb_private::RegisterCheckpoint > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__RegisterContext_t = {"_p_std__shared_ptrT_lldb_private__RegisterContext_t", "lldb::RegisterContextSP *|std::shared_ptr< lldb_private::RegisterContext > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__RegisterTypeBuilder_t = {"_p_std__shared_ptrT_lldb_private__RegisterTypeBuilder_t", "lldb::RegisterTypeBuilderSP *|std::shared_ptr< lldb_private::RegisterTypeBuilder > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__RegularExpression_t = {"_p_std__shared_ptrT_lldb_private__RegularExpression_t", "lldb::RegularExpressionSP *|std::shared_ptr< lldb_private::RegularExpression > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptInterpreter_t = {"_p_std__shared_ptrT_lldb_private__ScriptInterpreter_t", "lldb::ScriptInterpreterSP *|std::shared_ptr< lldb_private::ScriptInterpreter > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t = {"_p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t", "lldb::ScriptSummaryFormatSP *|std::shared_ptr< lldb_private::ScriptSummaryFormat > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptedBreakpointInterface_t = {"_p_std__shared_ptrT_lldb_private__ScriptedBreakpointInterface_t", "lldb::ScriptedBreakpointInterfaceSP *|std::shared_ptr< lldb_private::ScriptedBreakpointInterface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptedFrameInterface_t = {"_p_std__shared_ptrT_lldb_private__ScriptedFrameInterface_t", "lldb::ScriptedFrameInterfaceSP *|std::shared_ptr< lldb_private::ScriptedFrameInterface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptedFrameProviderInterface_t = {"_p_std__shared_ptrT_lldb_private__ScriptedFrameProviderInterface_t", "lldb::ScriptedFrameProviderInterfaceSP *|std::shared_ptr< lldb_private::ScriptedFrameProviderInterface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptedMetadata_t = {"_p_std__shared_ptrT_lldb_private__ScriptedMetadata_t", "lldb::ScriptedMetadataSP *|std::shared_ptr< lldb_private::ScriptedMetadata > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptedStopHookInterface_t = {"_p_std__shared_ptrT_lldb_private__ScriptedStopHookInterface_t", "lldb::ScriptedStopHookInterfaceSP *|std::shared_ptr< lldb_private::ScriptedStopHookInterface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t = {"_p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t", "lldb::ScriptedSyntheticChildrenSP *|std::shared_ptr< lldb_private::ScriptedSyntheticChildren > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t = {"_p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t", "lldb::ScriptedThreadInterfaceSP *|std::shared_ptr< lldb_private::ScriptedThreadInterface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ScriptedThreadPlanInterface_t = {"_p_std__shared_ptrT_lldb_private__ScriptedThreadPlanInterface_t", "lldb::ScriptedThreadPlanInterfaceSP *|std::shared_ptr< lldb_private::ScriptedThreadPlanInterface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SearchFilter_t = {"_p_std__shared_ptrT_lldb_private__SearchFilter_t", "lldb::SearchFilterSP *|std::shared_ptr< lldb_private::SearchFilter > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SectionLoadList_t = {"_p_std__shared_ptrT_lldb_private__SectionLoadList_t", "lldb::SectionLoadListSP *|std::shared_ptr< lldb_private::SectionLoadList > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Section_t = {"_p_std__shared_ptrT_lldb_private__Section_t", "lldb::SectionSP *|std::shared_ptr< lldb_private::Section > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__StackFrameList_t = {"_p_std__shared_ptrT_lldb_private__StackFrameList_t", "lldb::StackFrameListSP *|std::shared_ptr< lldb_private::StackFrameList > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t = {"_p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t", "lldb::StackFrameRecognizerSP *|std::shared_ptr< lldb_private::StackFrameRecognizer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__StackFrame_t = {"_p_std__shared_ptrT_lldb_private__StackFrame_t", "lldb::StackFrameSP *|std::shared_ptr< lldb_private::StackFrame > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__StopInfo_t = {"_p_std__shared_ptrT_lldb_private__StopInfo_t", "lldb::StopInfoSP *|std::shared_ptr< lldb_private::StopInfo > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__StreamFile_t = {"_p_std__shared_ptrT_lldb_private__StreamFile_t", "lldb::StreamFileSP *|std::shared_ptr< lldb_private::StreamFile > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Stream_t = {"_p_std__shared_ptrT_lldb_private__Stream_t", "lldb::StreamSP *|std::shared_ptr< lldb_private::Stream > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__StringSummaryFormat_t = {"_p_std__shared_ptrT_lldb_private__StringSummaryFormat_t", "lldb::StringTypeSummaryImplSP *|std::shared_ptr< lldb_private::StringSummaryFormat > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t = {"_p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t", "lldb::StructuredDataPluginSP *|std::shared_ptr< lldb_private::StructuredDataPlugin > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t = {"_p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t", "lldb::SymbolContextSpecifierSP *|std::shared_ptr< lldb_private::SymbolContextSpecifier > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SymbolFileType_t = {"_p_std__shared_ptrT_lldb_private__SymbolFileType_t", "lldb::SymbolFileTypeSP *|std::shared_ptr< lldb_private::SymbolFileType > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t = {"_p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t", "lldb::SyntheticChildrenFrontEndSP *|std::shared_ptr< lldb_private::SyntheticChildrenFrontEnd > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SyntheticChildren_t = {"_p_std__shared_ptrT_lldb_private__SyntheticChildren_t", "lldb::SyntheticChildrenSP *|std::shared_ptr< lldb_private::SyntheticChildren > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__SyntheticFrameProvider_t = {"_p_std__shared_ptrT_lldb_private__SyntheticFrameProvider_t", "lldb::SyntheticFrameProviderSP *|std::shared_ptr< lldb_private::SyntheticFrameProvider > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Target_t = {"_p_std__shared_ptrT_lldb_private__Target_t", "lldb::TargetSP *|std::shared_ptr< lldb_private::Target > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ThreadCollection_t = {"_p_std__shared_ptrT_lldb_private__ThreadCollection_t", "lldb::ThreadCollectionSP *|std::shared_ptr< lldb_private::ThreadCollection > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t = {"_p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t", "lldb::ThreadPlanTracerSP *|std::shared_ptr< lldb_private::ThreadPlanTracer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ThreadPlan_t = {"_p_std__shared_ptrT_lldb_private__ThreadPlan_t", "lldb::ThreadPlanSP *|std::shared_ptr< lldb_private::ThreadPlan > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t = {"_p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t", "lldb::ThreadPostMortemTraceSP *|std::shared_ptr< lldb_private::ThreadPostMortemTrace > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Thread_t = {"_p_std__shared_ptrT_lldb_private__Thread_t", "lldb::ThreadSP *|std::shared_ptr< lldb_private::Thread > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TraceCursor_t = {"_p_std__shared_ptrT_lldb_private__TraceCursor_t", "lldb::TraceCursorSP *|std::shared_ptr< lldb_private::TraceCursor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Trace_t = {"_p_std__shared_ptrT_lldb_private__Trace_t", "lldb::TraceSP *|std::shared_ptr< lldb_private::Trace > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t = {"_p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t", "lldb::TypeCategoryImplSP *|std::shared_ptr< lldb_private::TypeCategoryImpl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t = {"_p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t", "lldb::TypeEnumMemberImplSP *|std::shared_ptr< lldb_private::TypeEnumMemberImpl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeFilterImpl_t = {"_p_std__shared_ptrT_lldb_private__TypeFilterImpl_t", "lldb::TypeFilterImplSP *|std::shared_ptr< lldb_private::TypeFilterImpl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeFormatImpl_t = {"_p_std__shared_ptrT_lldb_private__TypeFormatImpl_t", "lldb::TypeFormatImplSP *|std::shared_ptr< lldb_private::TypeFormatImpl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeImpl_t = {"_p_std__shared_ptrT_lldb_private__TypeImpl_t", "lldb::TypeImplSP *|std::shared_ptr< lldb_private::TypeImpl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t = {"_p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t", "lldb::TypeMemberFunctionImplSP *|std::shared_ptr< lldb_private::TypeMemberFunctionImpl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t = {"_p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t", "lldb::TypeNameSpecifierImplSP *|std::shared_ptr< lldb_private::TypeNameSpecifierImpl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t = {"_p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t", "lldb::TypeSummaryImplSP *|std::shared_ptr< lldb_private::TypeSummaryImpl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t = {"_p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t", "lldb::TypeSummaryOptionsSP *|std::shared_ptr< lldb_private::TypeSummaryOptions > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeSystemClang_t = {"_p_std__shared_ptrT_lldb_private__TypeSystemClang_t", "lldb::TypeSystemClangSP *|std::shared_ptr< lldb_private::TypeSystemClang > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__TypeSystem_t = {"_p_std__shared_ptrT_lldb_private__TypeSystem_t", "lldb::TypeSystemSP *|std::shared_ptr< lldb_private::TypeSystem > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Type_t = {"_p_std__shared_ptrT_lldb_private__Type_t", "lldb::TypeSP *|std::shared_ptr< lldb_private::Type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__UnixSignals_t = {"_p_std__shared_ptrT_lldb_private__UnixSignals_t", "lldb::UnixSignalsSP *|std::shared_ptr< lldb_private::UnixSignals > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__UnwindAssembly_t = {"_p_std__shared_ptrT_lldb_private__UnwindAssembly_t", "lldb::UnwindAssemblySP *|std::shared_ptr< lldb_private::UnwindAssembly > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__UnwindPlan_t = {"_p_std__shared_ptrT_lldb_private__UnwindPlan_t", "lldb::UnwindPlanSP *|std::shared_ptr< lldb_private::UnwindPlan > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__UserExpression_t = {"_p_std__shared_ptrT_lldb_private__UserExpression_t", "lldb::UserExpressionSP *|std::shared_ptr< lldb_private::UserExpression > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ValueObjectList_t = {"_p_std__shared_ptrT_lldb_private__ValueObjectList_t", "lldb::ValueObjectListSP *|std::shared_ptr< lldb_private::ValueObjectList > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__ValueObject_t = {"_p_std__shared_ptrT_lldb_private__ValueObject_t", "lldb::ValueObjectSP *|std::shared_ptr< lldb_private::ValueObject > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Value_t = {"_p_std__shared_ptrT_lldb_private__Value_t", "lldb::ValueSP *|std::shared_ptr< lldb_private::Value > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__VariableList_t = {"_p_std__shared_ptrT_lldb_private__VariableList_t", "lldb::VariableListSP *|std::shared_ptr< lldb_private::VariableList > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Variable_t = {"_p_std__shared_ptrT_lldb_private__Variable_t", "lldb::VariableSP *|std::shared_ptr< lldb_private::Variable > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__WatchpointResource_t = {"_p_std__shared_ptrT_lldb_private__WatchpointResource_t", "lldb::WatchpointResourceSP *|std::shared_ptr< lldb_private::WatchpointResource > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__Watchpoint_t = {"_p_std__shared_ptrT_lldb_private__Watchpoint_t", "lldb::WatchpointSP *|std::shared_ptr< lldb_private::Watchpoint > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_lldb_private__WritableDataBuffer_t = {"_p_std__shared_ptrT_lldb_private__WritableDataBuffer_t", "lldb::WritableDataBufferSP *|std::shared_ptr< lldb_private::WritableDataBuffer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__AddressRange_t = {"_p_std__unique_ptrT_lldb_private__AddressRange_t", "lldb::AddressRangeUP *|std::unique_ptr< lldb_private::AddressRange > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__DataExtractor_t = {"_p_std__unique_ptrT_lldb_private__DataExtractor_t", "lldb::DataExtractorUP *|std::unique_ptr< lldb_private::DataExtractor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t = {"_p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t", "lldb::DynamicCheckerFunctionsUP *|std::unique_ptr< lldb_private::DynamicCheckerFunctions > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__DynamicLoader_t = {"_p_std__unique_ptrT_lldb_private__DynamicLoader_t", "lldb::DynamicLoaderUP *|std::unique_ptr< lldb_private::DynamicLoader > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__File_t = {"_p_std__unique_ptrT_lldb_private__File_t", "lldb::FileUP *|std::unique_ptr< lldb_private::File > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__JITLoaderList_t = {"_p_std__unique_ptrT_lldb_private__JITLoaderList_t", "lldb::JITLoaderListUP *|std::unique_ptr< lldb_private::JITLoaderList > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t = {"_p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t", "lldb::MemoryRegionInfoUP *|std::unique_ptr< lldb_private::MemoryRegionInfo > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__OperatingSystem_t = {"_p_std__unique_ptrT_lldb_private__OperatingSystem_t", "lldb::OperatingSystemUP *|std::unique_ptr< lldb_private::OperatingSystem > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__ProtocolServer_t = {"_p_std__unique_ptrT_lldb_private__ProtocolServer_t", "lldb::ProtocolServerUP *|std::unique_ptr< lldb_private::ProtocolServer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__ScriptedPlatformInterface_t = {"_p_std__unique_ptrT_lldb_private__ScriptedPlatformInterface_t", "lldb::ScriptedPlatformInterfaceUP *|std::unique_ptr< lldb_private::ScriptedPlatformInterface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t = {"_p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t", "lldb::ScriptedProcessInterfaceUP *|std::unique_ptr< lldb_private::ScriptedProcessInterface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__SectionList_t = {"_p_std__unique_ptrT_lldb_private__SectionList_t", "lldb::SectionListUP *|std::unique_ptr< lldb_private::SectionList > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__SourceManager_t = {"_p_std__unique_ptrT_lldb_private__SourceManager_t", "lldb::SourceManagerUP *|std::unique_ptr< lldb_private::SourceManager > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t = {"_p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t", "lldb::StackFrameRecognizerManagerUP *|std::unique_ptr< lldb_private::StackFrameRecognizerManager > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__Stream_t = {"_p_std__unique_ptrT_lldb_private__Stream_t", "lldb::StreamUP *|std::unique_ptr< lldb_private::Stream > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__StructuredDataImpl_t = {"_p_std__unique_ptrT_lldb_private__StructuredDataImpl_t", "lldb::StructuredDataImplUP *|std::unique_ptr< lldb_private::StructuredDataImpl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__SymbolVendor_t = {"_p_std__unique_ptrT_lldb_private__SymbolVendor_t", "lldb::SymbolVendorUP *|std::unique_ptr< lldb_private::SymbolVendor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__SystemRuntime_t = {"_p_std__unique_ptrT_lldb_private__SystemRuntime_t", "lldb::SystemRuntimeUP *|std::unique_ptr< lldb_private::SystemRuntime > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_lldb_private__TraceExporter_t = {"_p_std__unique_ptrT_lldb_private__TraceExporter_t", "lldb::TraceExporterUP *|std::unique_ptr< lldb_private::TraceExporter > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__BreakpointLocation_t = {"_p_std__weak_ptrT_lldb_private__BreakpointLocation_t", "lldb::BreakpointLocationWP *|std::weak_ptr< lldb_private::BreakpointLocation > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Breakpoint_t = {"_p_std__weak_ptrT_lldb_private__Breakpoint_t", "lldb::BreakpointWP *|std::weak_ptr< lldb_private::Breakpoint > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__BroadcasterManager_t = {"_p_std__weak_ptrT_lldb_private__BroadcasterManager_t", "lldb::BroadcasterManagerWP *|std::weak_ptr< lldb_private::BroadcasterManager > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Debugger_t = {"_p_std__weak_ptrT_lldb_private__Debugger_t", "lldb::DebuggerWP *|std::weak_ptr< lldb_private::Debugger > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Listener_t = {"_p_std__weak_ptrT_lldb_private__Listener_t", "lldb::ListenerWP *|std::weak_ptr< lldb_private::Listener > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Module_t = {"_p_std__weak_ptrT_lldb_private__Module_t", "lldb::ModuleWP *|std::weak_ptr< lldb_private::Module > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t = {"_p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t", "lldb::ObjectFileJITDelegateWP *|std::weak_ptr< lldb_private::ObjectFileJITDelegate > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__OptionValue_t = {"_p_std__weak_ptrT_lldb_private__OptionValue_t", "lldb::OptionValueWP *|std::weak_ptr< lldb_private::OptionValue > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Process_t = {"_p_std__weak_ptrT_lldb_private__Process_t", "lldb::ProcessWP *|std::weak_ptr< lldb_private::Process > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Queue_t = {"_p_std__weak_ptrT_lldb_private__Queue_t", "lldb::QueueWP *|std::weak_ptr< lldb_private::Queue > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Section_t = {"_p_std__weak_ptrT_lldb_private__Section_t", "lldb::SectionWP *|std::weak_ptr< lldb_private::Section > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__StackFrameList_t = {"_p_std__weak_ptrT_lldb_private__StackFrameList_t", "lldb::StackFrameListWP *|std::weak_ptr< lldb_private::StackFrameList > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__StackFrame_t = {"_p_std__weak_ptrT_lldb_private__StackFrame_t", "lldb::StackFrameWP *|std::weak_ptr< lldb_private::StackFrame > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t = {"_p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t", "lldb::StructuredDataPluginWP *|std::weak_ptr< lldb_private::StructuredDataPlugin > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Target_t = {"_p_std__weak_ptrT_lldb_private__Target_t", "lldb::TargetWP *|std::weak_ptr< lldb_private::Target > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__ThreadPlan_t = {"_p_std__weak_ptrT_lldb_private__ThreadPlan_t", "lldb::ThreadPlanWP *|std::weak_ptr< lldb_private::ThreadPlan > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Thread_t = {"_p_std__weak_ptrT_lldb_private__Thread_t", "lldb::ThreadWP *|std::weak_ptr< lldb_private::Thread > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__TypeSystem_t = {"_p_std__weak_ptrT_lldb_private__TypeSystem_t", "lldb::TypeSystemWP *|std::weak_ptr< lldb_private::TypeSystem > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__Type_t = {"_p_std__weak_ptrT_lldb_private__Type_t", "lldb::TypeWP *|std::weak_ptr< lldb_private::Type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__weak_ptrT_lldb_private__UnixSignals_t = {"_p_std__weak_ptrT_lldb_private__UnixSignals_t", "lldb::UnixSignalsWP *|std::weak_ptr< lldb_private::UnixSignals > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "uint8_t *|uint_fast8_t *|uint_least8_t *|unsigned char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "lldb::cpu_id_t *|lldb::frame_list_id_t *|lldb::wp_resource_id_t *|uint32_t *|uint_fast16_t *|uint_fast32_t *|uint_least32_t *|uintptr_t *|unsigned int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "lldb::addr_t *|lldb::offset_t *|lldb::pid_t *|lldb::process_t *|lldb::queue_id_t *|lldb::tid_t *|lldb::user_id_t *|uint64_t *|uint_fast64_t *|uint_least64_t *|uintmax_t *|unsigned long long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "uint16_t *|uint_least16_t *|unsigned short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_bool,
  &_swigt__p_char,
  &_swigt__p_double,
  &_swigt__p_f_p_void__p_void,
  &_swigt__p_f_p_void_p_q_const__void_size_t__void,
  &_swigt__p_int,
  &_swigt__p_lldb__ConnectionStatus,
  &_swigt__p_lldb__SBAddress,
  &_swigt__p_lldb__SBAddressRange,
  &_swigt__p_lldb__SBAddressRangeList,
  &_swigt__p_lldb__SBAttachInfo,
  &_swigt__p_lldb__SBBlock,
  &_swigt__p_lldb__SBBreakpoint,
  &_swigt__p_lldb__SBBreakpointList,
  &_swigt__p_lldb__SBBreakpointLocation,
  &_swigt__p_lldb__SBBreakpointName,
  &_swigt__p_lldb__SBBroadcaster,
  &_swigt__p_lldb__SBCommandInterpreter,
  &_swigt__p_lldb__SBCommandInterpreterRunOptions,
  &_swigt__p_lldb__SBCommandReturnObject,
  &_swigt__p_lldb__SBCommunication,
  &_swigt__p_lldb__SBCompileUnit,
  &_swigt__p_lldb__SBData,
  &_swigt__p_lldb__SBDebugger,
  &_swigt__p_lldb__SBDeclaration,
  &_swigt__p_lldb__SBEnvironment,
  &_swigt__p_lldb__SBError,
  &_swigt__p_lldb__SBEvent,
  &_swigt__p_lldb__SBExecutionContext,
  &_swigt__p_lldb__SBExpressionOptions,
  &_swigt__p_lldb__SBFile,
  &_swigt__p_lldb__SBFileSpec,
  &_swigt__p_lldb__SBFileSpecList,
  &_swigt__p_lldb__SBFormat,
  &_swigt__p_lldb__SBFrame,
  &_swigt__p_lldb__SBFrameList,
  &_swigt__p_lldb__SBFunction,
  &_swigt__p_lldb__SBHostOS,
  &_swigt__p_lldb__SBInstruction,
  &_swigt__p_lldb__SBInstructionList,
  &_swigt__p_lldb__SBLanguageRuntime,
  &_swigt__p_lldb__SBLaunchInfo,
  &_swigt__p_lldb__SBLineEntry,
  &_swigt__p_lldb__SBListener,
  &_swigt__p_lldb__SBMemoryRegionInfo,
  &_swigt__p_lldb__SBMemoryRegionInfoList,
  &_swigt__p_lldb__SBModule,
  &_swigt__p_lldb__SBModuleSpec,
  &_swigt__p_lldb__SBModuleSpecList,
  &_swigt__p_lldb__SBMutex,
  &_swigt__p_lldb__SBPlatform,
  &_swigt__p_lldb__SBPlatformConnectOptions,
  &_swigt__p_lldb__SBPlatformShellCommand,
  &_swigt__p_lldb__SBProcess,
  &_swigt__p_lldb__SBProcessInfo,
  &_swigt__p_lldb__SBProcessInfoList,
  &_swigt__p_lldb__SBProgress,
  &_swigt__p_lldb__SBQueue,
  &_swigt__p_lldb__SBQueueItem,
  &_swigt__p_lldb__SBReproducer,
  &_swigt__p_lldb__SBSaveCoreOptions,
  &_swigt__p_lldb__SBScriptObject,
  &_swigt__p_lldb__SBSection,
  &_swigt__p_lldb__SBSourceManager,
  &_swigt__p_lldb__SBStatisticsOptions,
  &_swigt__p_lldb__SBStream,
  &_swigt__p_lldb__SBStringList,
  &_swigt__p_lldb__SBStructuredData,
  &_swigt__p_lldb__SBSymbol,
  &_swigt__p_lldb__SBSymbolContext,
  &_swigt__p_lldb__SBSymbolContextList,
  &_swigt__p_lldb__SBTarget,
  &_swigt__p_lldb__SBThread,
  &_swigt__p_lldb__SBThreadCollection,
  &_swigt__p_lldb__SBThreadPlan,
  &_swigt__p_lldb__SBTrace,
  &_swigt__p_lldb__SBTraceCursor,
  &_swigt__p_lldb__SBType,
  &_swigt__p_lldb__SBTypeCategory,
  &_swigt__p_lldb__SBTypeEnumMember,
  &_swigt__p_lldb__SBTypeEnumMemberList,
  &_swigt__p_lldb__SBTypeFilter,
  &_swigt__p_lldb__SBTypeFormat,
  &_swigt__p_lldb__SBTypeList,
  &_swigt__p_lldb__SBTypeMember,
  &_swigt__p_lldb__SBTypeMemberFunction,
  &_swigt__p_lldb__SBTypeNameSpecifier,
  &_swigt__p_lldb__SBTypeStaticField,
  &_swigt__p_lldb__SBTypeSummary,
  &_swigt__p_lldb__SBTypeSummaryOptions,
  &_swigt__p_lldb__SBTypeSynthetic,
  &_swigt__p_lldb__SBUnixSignals,
  &_swigt__p_lldb__SBValue,
  &_swigt__p_lldb__SBValueList,
  &_swigt__p_lldb__SBVariablesOptions,
  &_swigt__p_lldb__SBWatchpoint,
  &_swigt__p_lldb__SBWatchpointOptions,
  &_swigt__p_long_double,
  &_swigt__p_long_long,
  &_swigt__p_p_void,
  &_swigt__p_pthread_rwlock_t,
  &_swigt__p_pthread_t,
  &_swigt__p_short,
  &_swigt__p_signed_char,
  &_swigt__p_size_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ABI_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Baton_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Block_t,
  &_swigt__p_std__shared_ptrT_lldb_private__BreakpointLocation_t,
  &_swigt__p_std__shared_ptrT_lldb_private__BreakpointPrecondition_t,
  &_swigt__p_std__shared_ptrT_lldb_private__BreakpointResolver_t,
  &_swigt__p_std__shared_ptrT_lldb_private__BreakpointSite_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Breakpoint_t,
  &_swigt__p_std__shared_ptrT_lldb_private__BroadcasterManager_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Broadcaster_t,
  &_swigt__p_std__shared_ptrT_lldb_private__CommandObject_t,
  &_swigt__p_std__shared_ptrT_lldb_private__CompileUnit_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Connection_t,
  &_swigt__p_std__shared_ptrT_lldb_private__DataBuffer_t,
  &_swigt__p_std__shared_ptrT_lldb_private__DataExtractor_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Debugger_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Disassembler_t,
  &_swigt__p_std__shared_ptrT_lldb_private__EventDataStructuredData_t,
  &_swigt__p_std__shared_ptrT_lldb_private__EventData_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Event_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ExecutionContextRef_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ExpressionVariable_t,
  &_swigt__p_std__shared_ptrT_lldb_private__File_t,
  &_swigt__p_std__shared_ptrT_lldb_private__FormatEntity__Entry_t,
  &_swigt__p_std__shared_ptrT_lldb_private__FuncUnwinders_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Function_t,
  &_swigt__p_std__shared_ptrT_lldb_private__IOHandler_t,
  &_swigt__p_std__shared_ptrT_lldb_private__IOObject_t,
  &_swigt__p_std__shared_ptrT_lldb_private__IRExecutionUnit_t,
  &_swigt__p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Instruction_t,
  &_swigt__p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t,
  &_swigt__p_std__shared_ptrT_lldb_private__JITLoader_t,
  &_swigt__p_std__shared_ptrT_lldb_private__LanguageRuntime_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Listener_t,
  &_swigt__p_std__shared_ptrT_lldb_private__LockableStreamFile_t,
  &_swigt__p_std__shared_ptrT_lldb_private__MemoryHistory_t,
  &_swigt__p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Module_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ObjectContainer_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ObjectFile_t,
  &_swigt__p_std__shared_ptrT_lldb_private__OperatingSystemInterface_t,
  &_swigt__p_std__shared_ptrT_lldb_private__OptionValueProperties_t,
  &_swigt__p_std__shared_ptrT_lldb_private__OptionValue_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Platform_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ProcessLaunchInfo_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Process_t,
  &_swigt__p_std__shared_ptrT_lldb_private__QueueItem_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Queue_t,
  &_swigt__p_std__shared_ptrT_lldb_private__REPL_t,
  &_swigt__p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t,
  &_swigt__p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t,
  &_swigt__p_std__shared_ptrT_lldb_private__RegisterContext_t,
  &_swigt__p_std__shared_ptrT_lldb_private__RegisterTypeBuilder_t,
  &_swigt__p_std__shared_ptrT_lldb_private__RegularExpression_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ScriptInterpreter_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ScriptedBreakpointInterface_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ScriptedFrameInterface_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ScriptedFrameProviderInterface_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ScriptedMetadata_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ScriptedStopHookInterface_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ScriptedThreadPlanInterface_t,
  &_swigt__p_std__shared_ptrT_lldb_private__SearchFilter_t,
  &_swigt__p_std__shared_ptrT_lldb_private__SectionLoadList_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Section_t,
  &_swigt__p_std__shared_ptrT_lldb_private__StackFrameList_t,
  &_swigt__p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t,
  &_swigt__p_std__shared_ptrT_lldb_private__StackFrame_t,
  &_swigt__p_std__shared_ptrT_lldb_private__StopInfo_t,
  &_swigt__p_std__shared_ptrT_lldb_private__StreamFile_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Stream_t,
  &_swigt__p_std__shared_ptrT_lldb_private__StringSummaryFormat_t,
  &_swigt__p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t,
  &_swigt__p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t,
  &_swigt__p_std__shared_ptrT_lldb_private__SymbolFileType_t,
  &_swigt__p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t,
  &_swigt__p_std__shared_ptrT_lldb_private__SyntheticChildren_t,
  &_swigt__p_std__shared_ptrT_lldb_private__SyntheticFrameProvider_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Target_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ThreadCollection_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ThreadPlan_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Thread_t,
  &_swigt__p_std__shared_ptrT_lldb_private__TraceCursor_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Trace_t,
  &_swigt__p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t,
  &_swigt__p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t,
  &_swigt__p_std__shared_ptrT_lldb_private__TypeFilterImpl_t,
  &_swigt__p_std__shared_ptrT_lldb_private__TypeFormatImpl_t,
  &_swigt__p_std__shared_ptrT_lldb_private__TypeImpl_t,
  &_swigt__p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t,
  &_swigt__p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t,
  &_swigt__p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t,
  &_swigt__p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t,
  &_swigt__p_std__shared_ptrT_lldb_private__TypeSystemClang_t,
  &_swigt__p_std__shared_ptrT_lldb_private__TypeSystem_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Type_t,
  &_swigt__p_std__shared_ptrT_lldb_private__UnixSignals_t,
  &_swigt__p_std__shared_ptrT_lldb_private__UnwindAssembly_t,
  &_swigt__p_std__shared_ptrT_lldb_private__UnwindPlan_t,
  &_swigt__p_std__shared_ptrT_lldb_private__UserExpression_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ValueObjectList_t,
  &_swigt__p_std__shared_ptrT_lldb_private__ValueObject_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Value_t,
  &_swigt__p_std__shared_ptrT_lldb_private__VariableList_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Variable_t,
  &_swigt__p_std__shared_ptrT_lldb_private__WatchpointResource_t,
  &_swigt__p_std__shared_ptrT_lldb_private__Watchpoint_t,
  &_swigt__p_std__shared_ptrT_lldb_private__WritableDataBuffer_t,
  &_swigt__p_std__unique_ptrT_lldb_private__AddressRange_t,
  &_swigt__p_std__unique_ptrT_lldb_private__DataExtractor_t,
  &_swigt__p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t,
  &_swigt__p_std__unique_ptrT_lldb_private__DynamicLoader_t,
  &_swigt__p_std__unique_ptrT_lldb_private__File_t,
  &_swigt__p_std__unique_ptrT_lldb_private__JITLoaderList_t,
  &_swigt__p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t,
  &_swigt__p_std__unique_ptrT_lldb_private__OperatingSystem_t,
  &_swigt__p_std__unique_ptrT_lldb_private__ProtocolServer_t,
  &_swigt__p_std__unique_ptrT_lldb_private__ScriptedPlatformInterface_t,
  &_swigt__p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t,
  &_swigt__p_std__unique_ptrT_lldb_private__SectionList_t,
  &_swigt__p_std__unique_ptrT_lldb_private__SourceManager_t,
  &_swigt__p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t,
  &_swigt__p_std__unique_ptrT_lldb_private__Stream_t,
  &_swigt__p_std__unique_ptrT_lldb_private__StructuredDataImpl_t,
  &_swigt__p_std__unique_ptrT_lldb_private__SymbolVendor_t,
  &_swigt__p_std__unique_ptrT_lldb_private__SystemRuntime_t,
  &_swigt__p_std__unique_ptrT_lldb_private__TraceExporter_t,
  &_swigt__p_std__weak_ptrT_lldb_private__BreakpointLocation_t,
  &_swigt__p_std__weak_ptrT_lldb_private__Breakpoint_t,
  &_swigt__p_std__weak_ptrT_lldb_private__BroadcasterManager_t,
  &_swigt__p_std__weak_ptrT_lldb_private__Debugger_t,
  &_swigt__p_std__weak_ptrT_lldb_private__Listener_t,
  &_swigt__p_std__weak_ptrT_lldb_private__Module_t,
  &_swigt__p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t,
  &_swigt__p_std__weak_ptrT_lldb_private__OptionValue_t,
  &_swigt__p_std__weak_ptrT_lldb_private__Process_t,
  &_swigt__p_std__weak_ptrT_lldb_private__Queue_t,
  &_swigt__p_std__weak_ptrT_lldb_private__Section_t,
  &_swigt__p_std__weak_ptrT_lldb_private__StackFrameList_t,
  &_swigt__p_std__weak_ptrT_lldb_private__StackFrame_t,
  &_swigt__p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t,
  &_swigt__p_std__weak_ptrT_lldb_private__Target_t,
  &_swigt__p_std__weak_ptrT_lldb_private__ThreadPlan_t,
  &_swigt__p_std__weak_ptrT_lldb_private__Thread_t,
  &_swigt__p_std__weak_ptrT_lldb_private__TypeSystem_t,
  &_swigt__p_std__weak_ptrT_lldb_private__Type_t,
  &_swigt__p_std__weak_ptrT_lldb_private__UnixSignals_t,
  &_swigt__p_unsigned_char,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_long_long,
  &_swigt__p_unsigned_short,
  &_swigt__p_void,
};

static swig_cast_info _swigc__p_bool[] = {  {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void__p_void[] = {  {&_swigt__p_f_p_void__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__void_size_t__void[] = {  {&_swigt__p_f_p_void_p_q_const__void_size_t__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__ConnectionStatus[] = {  {&_swigt__p_lldb__ConnectionStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBAddress[] = {  {&_swigt__p_lldb__SBAddress, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBAddressRange[] = {  {&_swigt__p_lldb__SBAddressRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBAddressRangeList[] = {  {&_swigt__p_lldb__SBAddressRangeList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBAttachInfo[] = {  {&_swigt__p_lldb__SBAttachInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBBlock[] = {  {&_swigt__p_lldb__SBBlock, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBBreakpoint[] = {  {&_swigt__p_lldb__SBBreakpoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBBreakpointList[] = {  {&_swigt__p_lldb__SBBreakpointList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBBreakpointLocation[] = {  {&_swigt__p_lldb__SBBreakpointLocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBBreakpointName[] = {  {&_swigt__p_lldb__SBBreakpointName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBBroadcaster[] = {  {&_swigt__p_lldb__SBBroadcaster, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBCommandInterpreter[] = {  {&_swigt__p_lldb__SBCommandInterpreter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBCommandInterpreterRunOptions[] = {  {&_swigt__p_lldb__SBCommandInterpreterRunOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBCommandReturnObject[] = {  {&_swigt__p_lldb__SBCommandReturnObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBCommunication[] = {  {&_swigt__p_lldb__SBCommunication, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBCompileUnit[] = {  {&_swigt__p_lldb__SBCompileUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBData[] = {  {&_swigt__p_lldb__SBData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBDebugger[] = {  {&_swigt__p_lldb__SBDebugger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBDeclaration[] = {  {&_swigt__p_lldb__SBDeclaration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBEnvironment[] = {  {&_swigt__p_lldb__SBEnvironment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBError[] = {  {&_swigt__p_lldb__SBError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBEvent[] = {  {&_swigt__p_lldb__SBEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBExecutionContext[] = {  {&_swigt__p_lldb__SBExecutionContext, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBExpressionOptions[] = {  {&_swigt__p_lldb__SBExpressionOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBFile[] = {  {&_swigt__p_lldb__SBFile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBFileSpec[] = {  {&_swigt__p_lldb__SBFileSpec, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBFileSpecList[] = {  {&_swigt__p_lldb__SBFileSpecList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBFormat[] = {  {&_swigt__p_lldb__SBFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBFrame[] = {  {&_swigt__p_lldb__SBFrame, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBFrameList[] = {  {&_swigt__p_lldb__SBFrameList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBFunction[] = {  {&_swigt__p_lldb__SBFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBHostOS[] = {  {&_swigt__p_lldb__SBHostOS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBInstruction[] = {  {&_swigt__p_lldb__SBInstruction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBInstructionList[] = {  {&_swigt__p_lldb__SBInstructionList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBLanguageRuntime[] = {  {&_swigt__p_lldb__SBLanguageRuntime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBLaunchInfo[] = {  {&_swigt__p_lldb__SBLaunchInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBLineEntry[] = {  {&_swigt__p_lldb__SBLineEntry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBListener[] = {  {&_swigt__p_lldb__SBListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBMemoryRegionInfo[] = {  {&_swigt__p_lldb__SBMemoryRegionInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBMemoryRegionInfoList[] = {  {&_swigt__p_lldb__SBMemoryRegionInfoList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBModule[] = {  {&_swigt__p_lldb__SBModule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBModuleSpec[] = {  {&_swigt__p_lldb__SBModuleSpec, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBModuleSpecList[] = {  {&_swigt__p_lldb__SBModuleSpecList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBMutex[] = {  {&_swigt__p_lldb__SBMutex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBPlatform[] = {  {&_swigt__p_lldb__SBPlatform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBPlatformConnectOptions[] = {  {&_swigt__p_lldb__SBPlatformConnectOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBPlatformShellCommand[] = {  {&_swigt__p_lldb__SBPlatformShellCommand, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBProcess[] = {  {&_swigt__p_lldb__SBProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBProcessInfo[] = {  {&_swigt__p_lldb__SBProcessInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBProcessInfoList[] = {  {&_swigt__p_lldb__SBProcessInfoList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBProgress[] = {  {&_swigt__p_lldb__SBProgress, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBQueue[] = {  {&_swigt__p_lldb__SBQueue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBQueueItem[] = {  {&_swigt__p_lldb__SBQueueItem, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBReproducer[] = {  {&_swigt__p_lldb__SBReproducer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBSaveCoreOptions[] = {  {&_swigt__p_lldb__SBSaveCoreOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBScriptObject[] = {  {&_swigt__p_lldb__SBScriptObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBSection[] = {  {&_swigt__p_lldb__SBSection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBSourceManager[] = {  {&_swigt__p_lldb__SBSourceManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBStatisticsOptions[] = {  {&_swigt__p_lldb__SBStatisticsOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBStream[] = {  {&_swigt__p_lldb__SBStream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBStringList[] = {  {&_swigt__p_lldb__SBStringList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBStructuredData[] = {  {&_swigt__p_lldb__SBStructuredData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBSymbol[] = {  {&_swigt__p_lldb__SBSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBSymbolContext[] = {  {&_swigt__p_lldb__SBSymbolContext, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBSymbolContextList[] = {  {&_swigt__p_lldb__SBSymbolContextList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTarget[] = {  {&_swigt__p_lldb__SBTarget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBThread[] = {  {&_swigt__p_lldb__SBThread, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBThreadCollection[] = {  {&_swigt__p_lldb__SBThreadCollection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBThreadPlan[] = {  {&_swigt__p_lldb__SBThreadPlan, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTrace[] = {  {&_swigt__p_lldb__SBTrace, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTraceCursor[] = {  {&_swigt__p_lldb__SBTraceCursor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBType[] = {  {&_swigt__p_lldb__SBType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeCategory[] = {  {&_swigt__p_lldb__SBTypeCategory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeEnumMember[] = {  {&_swigt__p_lldb__SBTypeEnumMember, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeEnumMemberList[] = {  {&_swigt__p_lldb__SBTypeEnumMemberList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeFilter[] = {  {&_swigt__p_lldb__SBTypeFilter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeFormat[] = {  {&_swigt__p_lldb__SBTypeFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeList[] = {  {&_swigt__p_lldb__SBTypeList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeMember[] = {  {&_swigt__p_lldb__SBTypeMember, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeMemberFunction[] = {  {&_swigt__p_lldb__SBTypeMemberFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeNameSpecifier[] = {  {&_swigt__p_lldb__SBTypeNameSpecifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeStaticField[] = {  {&_swigt__p_lldb__SBTypeStaticField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeSummary[] = {  {&_swigt__p_lldb__SBTypeSummary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeSummaryOptions[] = {  {&_swigt__p_lldb__SBTypeSummaryOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBTypeSynthetic[] = {  {&_swigt__p_lldb__SBTypeSynthetic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBUnixSignals[] = {  {&_swigt__p_lldb__SBUnixSignals, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBValue[] = {  {&_swigt__p_lldb__SBValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBValueList[] = {  {&_swigt__p_lldb__SBValueList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBVariablesOptions[] = {  {&_swigt__p_lldb__SBVariablesOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBWatchpoint[] = {  {&_swigt__p_lldb__SBWatchpoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_lldb__SBWatchpointOptions[] = {  {&_swigt__p_lldb__SBWatchpointOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_double[] = {  {&_swigt__p_long_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_void[] = {  {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_pthread_rwlock_t[] = {  {&_swigt__p_pthread_rwlock_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_pthread_t[] = {  {&_swigt__p_pthread_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_t[] = {  {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ABI_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ABI_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Baton_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Baton_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Block_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Block_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__BreakpointLocation_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__BreakpointLocation_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__BreakpointPrecondition_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__BreakpointPrecondition_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__BreakpointResolver_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__BreakpointResolver_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__BreakpointSite_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__BreakpointSite_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Breakpoint_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Breakpoint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__BroadcasterManager_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__BroadcasterManager_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Broadcaster_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Broadcaster_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__CommandObject_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__CommandObject_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__CompileUnit_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__CompileUnit_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Connection_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Connection_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__DataBuffer_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__DataBuffer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__DataExtractor_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__DataExtractor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Debugger_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Debugger_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Disassembler_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Disassembler_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__EventDataStructuredData_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__EventDataStructuredData_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__EventData_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__EventData_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Event_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Event_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ExecutionContextRef_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ExecutionContextRef_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ExpressionVariable_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ExpressionVariable_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__File_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__File_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__FormatEntity__Entry_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__FormatEntity__Entry_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__FuncUnwinders_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__FuncUnwinders_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Function_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Function_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__IOHandler_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__IOHandler_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__IOObject_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__IOObject_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__IRExecutionUnit_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__IRExecutionUnit_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Instruction_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Instruction_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__JITLoader_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__JITLoader_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__LanguageRuntime_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__LanguageRuntime_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Listener_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Listener_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__LockableStreamFile_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__LockableStreamFile_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__MemoryHistory_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__MemoryHistory_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Module_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Module_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ObjectContainer_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ObjectContainer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ObjectFile_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ObjectFile_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__OperatingSystemInterface_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__OperatingSystemInterface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__OptionValueProperties_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__OptionValueProperties_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__OptionValue_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__OptionValue_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Platform_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Platform_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ProcessLaunchInfo_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ProcessLaunchInfo_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Process_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Process_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__QueueItem_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__QueueItem_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Queue_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Queue_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__REPL_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__REPL_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__RegisterContext_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__RegisterContext_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__RegisterTypeBuilder_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__RegisterTypeBuilder_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__RegularExpression_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__RegularExpression_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptInterpreter_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ScriptInterpreter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptedBreakpointInterface_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ScriptedBreakpointInterface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptedFrameInterface_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ScriptedFrameInterface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptedFrameProviderInterface_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ScriptedFrameProviderInterface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptedMetadata_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ScriptedMetadata_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptedStopHookInterface_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ScriptedStopHookInterface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ScriptedThreadPlanInterface_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ScriptedThreadPlanInterface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SearchFilter_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__SearchFilter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SectionLoadList_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__SectionLoadList_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Section_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Section_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__StackFrameList_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__StackFrameList_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__StackFrame_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__StackFrame_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__StopInfo_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__StopInfo_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__StreamFile_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__StreamFile_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Stream_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Stream_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__StringSummaryFormat_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__StringSummaryFormat_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SymbolFileType_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__SymbolFileType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SyntheticChildren_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__SyntheticChildren_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__SyntheticFrameProvider_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__SyntheticFrameProvider_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Target_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Target_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ThreadCollection_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ThreadCollection_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ThreadPlan_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ThreadPlan_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Thread_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Thread_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TraceCursor_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__TraceCursor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Trace_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Trace_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeFilterImpl_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__TypeFilterImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeFormatImpl_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__TypeFormatImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeImpl_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__TypeImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeSystemClang_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__TypeSystemClang_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__TypeSystem_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__TypeSystem_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Type_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__UnixSignals_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__UnixSignals_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__UnwindAssembly_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__UnwindAssembly_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__UnwindPlan_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__UnwindPlan_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__UserExpression_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__UserExpression_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ValueObjectList_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ValueObjectList_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__ValueObject_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__ValueObject_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Value_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Value_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__VariableList_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__VariableList_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Variable_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Variable_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__WatchpointResource_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__WatchpointResource_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__Watchpoint_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__Watchpoint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_lldb_private__WritableDataBuffer_t[] = {  {&_swigt__p_std__shared_ptrT_lldb_private__WritableDataBuffer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__AddressRange_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__AddressRange_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__DataExtractor_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__DataExtractor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__DynamicLoader_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__DynamicLoader_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__File_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__File_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__JITLoaderList_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__JITLoaderList_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__OperatingSystem_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__OperatingSystem_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__ProtocolServer_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__ProtocolServer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__ScriptedPlatformInterface_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__ScriptedPlatformInterface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__SectionList_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__SectionList_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__SourceManager_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__SourceManager_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__Stream_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__Stream_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__StructuredDataImpl_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__StructuredDataImpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__SymbolVendor_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__SymbolVendor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__SystemRuntime_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__SystemRuntime_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_lldb_private__TraceExporter_t[] = {  {&_swigt__p_std__unique_ptrT_lldb_private__TraceExporter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__BreakpointLocation_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__BreakpointLocation_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Breakpoint_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__Breakpoint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__BroadcasterManager_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__BroadcasterManager_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Debugger_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__Debugger_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Listener_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__Listener_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Module_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__Module_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__OptionValue_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__OptionValue_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Process_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__Process_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Queue_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__Queue_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Section_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__Section_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__StackFrameList_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__StackFrameList_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__StackFrame_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__StackFrame_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Target_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__Target_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__ThreadPlan_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__ThreadPlan_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Thread_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__Thread_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__TypeSystem_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__TypeSystem_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__Type_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__Type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__weak_ptrT_lldb_private__UnixSignals_t[] = {  {&_swigt__p_std__weak_ptrT_lldb_private__UnixSignals_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_bool,
  _swigc__p_char,
  _swigc__p_double,
  _swigc__p_f_p_void__p_void,
  _swigc__p_f_p_void_p_q_const__void_size_t__void,
  _swigc__p_int,
  _swigc__p_lldb__ConnectionStatus,
  _swigc__p_lldb__SBAddress,
  _swigc__p_lldb__SBAddressRange,
  _swigc__p_lldb__SBAddressRangeList,
  _swigc__p_lldb__SBAttachInfo,
  _swigc__p_lldb__SBBlock,
  _swigc__p_lldb__SBBreakpoint,
  _swigc__p_lldb__SBBreakpointList,
  _swigc__p_lldb__SBBreakpointLocation,
  _swigc__p_lldb__SBBreakpointName,
  _swigc__p_lldb__SBBroadcaster,
  _swigc__p_lldb__SBCommandInterpreter,
  _swigc__p_lldb__SBCommandInterpreterRunOptions,
  _swigc__p_lldb__SBCommandReturnObject,
  _swigc__p_lldb__SBCommunication,
  _swigc__p_lldb__SBCompileUnit,
  _swigc__p_lldb__SBData,
  _swigc__p_lldb__SBDebugger,
  _swigc__p_lldb__SBDeclaration,
  _swigc__p_lldb__SBEnvironment,
  _swigc__p_lldb__SBError,
  _swigc__p_lldb__SBEvent,
  _swigc__p_lldb__SBExecutionContext,
  _swigc__p_lldb__SBExpressionOptions,
  _swigc__p_lldb__SBFile,
  _swigc__p_lldb__SBFileSpec,
  _swigc__p_lldb__SBFileSpecList,
  _swigc__p_lldb__SBFormat,
  _swigc__p_lldb__SBFrame,
  _swigc__p_lldb__SBFrameList,
  _swigc__p_lldb__SBFunction,
  _swigc__p_lldb__SBHostOS,
  _swigc__p_lldb__SBInstruction,
  _swigc__p_lldb__SBInstructionList,
  _swigc__p_lldb__SBLanguageRuntime,
  _swigc__p_lldb__SBLaunchInfo,
  _swigc__p_lldb__SBLineEntry,
  _swigc__p_lldb__SBListener,
  _swigc__p_lldb__SBMemoryRegionInfo,
  _swigc__p_lldb__SBMemoryRegionInfoList,
  _swigc__p_lldb__SBModule,
  _swigc__p_lldb__SBModuleSpec,
  _swigc__p_lldb__SBModuleSpecList,
  _swigc__p_lldb__SBMutex,
  _swigc__p_lldb__SBPlatform,
  _swigc__p_lldb__SBPlatformConnectOptions,
  _swigc__p_lldb__SBPlatformShellCommand,
  _swigc__p_lldb__SBProcess,
  _swigc__p_lldb__SBProcessInfo,
  _swigc__p_lldb__SBProcessInfoList,
  _swigc__p_lldb__SBProgress,
  _swigc__p_lldb__SBQueue,
  _swigc__p_lldb__SBQueueItem,
  _swigc__p_lldb__SBReproducer,
  _swigc__p_lldb__SBSaveCoreOptions,
  _swigc__p_lldb__SBScriptObject,
  _swigc__p_lldb__SBSection,
  _swigc__p_lldb__SBSourceManager,
  _swigc__p_lldb__SBStatisticsOptions,
  _swigc__p_lldb__SBStream,
  _swigc__p_lldb__SBStringList,
  _swigc__p_lldb__SBStructuredData,
  _swigc__p_lldb__SBSymbol,
  _swigc__p_lldb__SBSymbolContext,
  _swigc__p_lldb__SBSymbolContextList,
  _swigc__p_lldb__SBTarget,
  _swigc__p_lldb__SBThread,
  _swigc__p_lldb__SBThreadCollection,
  _swigc__p_lldb__SBThreadPlan,
  _swigc__p_lldb__SBTrace,
  _swigc__p_lldb__SBTraceCursor,
  _swigc__p_lldb__SBType,
  _swigc__p_lldb__SBTypeCategory,
  _swigc__p_lldb__SBTypeEnumMember,
  _swigc__p_lldb__SBTypeEnumMemberList,
  _swigc__p_lldb__SBTypeFilter,
  _swigc__p_lldb__SBTypeFormat,
  _swigc__p_lldb__SBTypeList,
  _swigc__p_lldb__SBTypeMember,
  _swigc__p_lldb__SBTypeMemberFunction,
  _swigc__p_lldb__SBTypeNameSpecifier,
  _swigc__p_lldb__SBTypeStaticField,
  _swigc__p_lldb__SBTypeSummary,
  _swigc__p_lldb__SBTypeSummaryOptions,
  _swigc__p_lldb__SBTypeSynthetic,
  _swigc__p_lldb__SBUnixSignals,
  _swigc__p_lldb__SBValue,
  _swigc__p_lldb__SBValueList,
  _swigc__p_lldb__SBVariablesOptions,
  _swigc__p_lldb__SBWatchpoint,
  _swigc__p_lldb__SBWatchpointOptions,
  _swigc__p_long_double,
  _swigc__p_long_long,
  _swigc__p_p_void,
  _swigc__p_pthread_rwlock_t,
  _swigc__p_pthread_t,
  _swigc__p_short,
  _swigc__p_signed_char,
  _swigc__p_size_t,
  _swigc__p_std__shared_ptrT_lldb_private__ABI_t,
  _swigc__p_std__shared_ptrT_lldb_private__Baton_t,
  _swigc__p_std__shared_ptrT_lldb_private__Block_t,
  _swigc__p_std__shared_ptrT_lldb_private__BreakpointLocation_t,
  _swigc__p_std__shared_ptrT_lldb_private__BreakpointPrecondition_t,
  _swigc__p_std__shared_ptrT_lldb_private__BreakpointResolver_t,
  _swigc__p_std__shared_ptrT_lldb_private__BreakpointSite_t,
  _swigc__p_std__shared_ptrT_lldb_private__Breakpoint_t,
  _swigc__p_std__shared_ptrT_lldb_private__BroadcasterManager_t,
  _swigc__p_std__shared_ptrT_lldb_private__Broadcaster_t,
  _swigc__p_std__shared_ptrT_lldb_private__CommandObject_t,
  _swigc__p_std__shared_ptrT_lldb_private__CompileUnit_t,
  _swigc__p_std__shared_ptrT_lldb_private__Connection_t,
  _swigc__p_std__shared_ptrT_lldb_private__DataBuffer_t,
  _swigc__p_std__shared_ptrT_lldb_private__DataExtractor_t,
  _swigc__p_std__shared_ptrT_lldb_private__Debugger_t,
  _swigc__p_std__shared_ptrT_lldb_private__Disassembler_t,
  _swigc__p_std__shared_ptrT_lldb_private__EventDataStructuredData_t,
  _swigc__p_std__shared_ptrT_lldb_private__EventData_t,
  _swigc__p_std__shared_ptrT_lldb_private__Event_t,
  _swigc__p_std__shared_ptrT_lldb_private__ExecutionContextRef_t,
  _swigc__p_std__shared_ptrT_lldb_private__ExpressionVariable_t,
  _swigc__p_std__shared_ptrT_lldb_private__File_t,
  _swigc__p_std__shared_ptrT_lldb_private__FormatEntity__Entry_t,
  _swigc__p_std__shared_ptrT_lldb_private__FuncUnwinders_t,
  _swigc__p_std__shared_ptrT_lldb_private__Function_t,
  _swigc__p_std__shared_ptrT_lldb_private__IOHandler_t,
  _swigc__p_std__shared_ptrT_lldb_private__IOObject_t,
  _swigc__p_std__shared_ptrT_lldb_private__IRExecutionUnit_t,
  _swigc__p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t,
  _swigc__p_std__shared_ptrT_lldb_private__Instruction_t,
  _swigc__p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t,
  _swigc__p_std__shared_ptrT_lldb_private__JITLoader_t,
  _swigc__p_std__shared_ptrT_lldb_private__LanguageRuntime_t,
  _swigc__p_std__shared_ptrT_lldb_private__Listener_t,
  _swigc__p_std__shared_ptrT_lldb_private__LockableStreamFile_t,
  _swigc__p_std__shared_ptrT_lldb_private__MemoryHistory_t,
  _swigc__p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t,
  _swigc__p_std__shared_ptrT_lldb_private__Module_t,
  _swigc__p_std__shared_ptrT_lldb_private__ObjectContainer_t,
  _swigc__p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t,
  _swigc__p_std__shared_ptrT_lldb_private__ObjectFile_t,
  _swigc__p_std__shared_ptrT_lldb_private__OperatingSystemInterface_t,
  _swigc__p_std__shared_ptrT_lldb_private__OptionValueProperties_t,
  _swigc__p_std__shared_ptrT_lldb_private__OptionValue_t,
  _swigc__p_std__shared_ptrT_lldb_private__Platform_t,
  _swigc__p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t,
  _swigc__p_std__shared_ptrT_lldb_private__ProcessLaunchInfo_t,
  _swigc__p_std__shared_ptrT_lldb_private__Process_t,
  _swigc__p_std__shared_ptrT_lldb_private__QueueItem_t,
  _swigc__p_std__shared_ptrT_lldb_private__Queue_t,
  _swigc__p_std__shared_ptrT_lldb_private__REPL_t,
  _swigc__p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t,
  _swigc__p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t,
  _swigc__p_std__shared_ptrT_lldb_private__RegisterContext_t,
  _swigc__p_std__shared_ptrT_lldb_private__RegisterTypeBuilder_t,
  _swigc__p_std__shared_ptrT_lldb_private__RegularExpression_t,
  _swigc__p_std__shared_ptrT_lldb_private__ScriptInterpreter_t,
  _swigc__p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t,
  _swigc__p_std__shared_ptrT_lldb_private__ScriptedBreakpointInterface_t,
  _swigc__p_std__shared_ptrT_lldb_private__ScriptedFrameInterface_t,
  _swigc__p_std__shared_ptrT_lldb_private__ScriptedFrameProviderInterface_t,
  _swigc__p_std__shared_ptrT_lldb_private__ScriptedMetadata_t,
  _swigc__p_std__shared_ptrT_lldb_private__ScriptedStopHookInterface_t,
  _swigc__p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t,
  _swigc__p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t,
  _swigc__p_std__shared_ptrT_lldb_private__ScriptedThreadPlanInterface_t,
  _swigc__p_std__shared_ptrT_lldb_private__SearchFilter_t,
  _swigc__p_std__shared_ptrT_lldb_private__SectionLoadList_t,
  _swigc__p_std__shared_ptrT_lldb_private__Section_t,
  _swigc__p_std__shared_ptrT_lldb_private__StackFrameList_t,
  _swigc__p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t,
  _swigc__p_std__shared_ptrT_lldb_private__StackFrame_t,
  _swigc__p_std__shared_ptrT_lldb_private__StopInfo_t,
  _swigc__p_std__shared_ptrT_lldb_private__StreamFile_t,
  _swigc__p_std__shared_ptrT_lldb_private__Stream_t,
  _swigc__p_std__shared_ptrT_lldb_private__StringSummaryFormat_t,
  _swigc__p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t,
  _swigc__p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t,
  _swigc__p_std__shared_ptrT_lldb_private__SymbolFileType_t,
  _swigc__p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t,
  _swigc__p_std__shared_ptrT_lldb_private__SyntheticChildren_t,
  _swigc__p_std__shared_ptrT_lldb_private__SyntheticFrameProvider_t,
  _swigc__p_std__shared_ptrT_lldb_private__Target_t,
  _swigc__p_std__shared_ptrT_lldb_private__ThreadCollection_t,
  _swigc__p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t,
  _swigc__p_std__shared_ptrT_lldb_private__ThreadPlan_t,
  _swigc__p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t,
  _swigc__p_std__shared_ptrT_lldb_private__Thread_t,
  _swigc__p_std__shared_ptrT_lldb_private__TraceCursor_t,
  _swigc__p_std__shared_ptrT_lldb_private__Trace_t,
  _swigc__p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t,
  _swigc__p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t,
  _swigc__p_std__shared_ptrT_lldb_private__TypeFilterImpl_t,
  _swigc__p_std__shared_ptrT_lldb_private__TypeFormatImpl_t,
  _swigc__p_std__shared_ptrT_lldb_private__TypeImpl_t,
  _swigc__p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t,
  _swigc__p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t,
  _swigc__p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t,
  _swigc__p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t,
  _swigc__p_std__shared_ptrT_lldb_private__TypeSystemClang_t,
  _swigc__p_std__shared_ptrT_lldb_private__TypeSystem_t,
  _swigc__p_std__shared_ptrT_lldb_private__Type_t,
  _swigc__p_std__shared_ptrT_lldb_private__UnixSignals_t,
  _swigc__p_std__shared_ptrT_lldb_private__UnwindAssembly_t,
  _swigc__p_std__shared_ptrT_lldb_private__UnwindPlan_t,
  _swigc__p_std__shared_ptrT_lldb_private__UserExpression_t,
  _swigc__p_std__shared_ptrT_lldb_private__ValueObjectList_t,
  _swigc__p_std__shared_ptrT_lldb_private__ValueObject_t,
  _swigc__p_std__shared_ptrT_lldb_private__Value_t,
  _swigc__p_std__shared_ptrT_lldb_private__VariableList_t,
  _swigc__p_std__shared_ptrT_lldb_private__Variable_t,
  _swigc__p_std__shared_ptrT_lldb_private__WatchpointResource_t,
  _swigc__p_std__shared_ptrT_lldb_private__Watchpoint_t,
  _swigc__p_std__shared_ptrT_lldb_private__WritableDataBuffer_t,
  _swigc__p_std__unique_ptrT_lldb_private__AddressRange_t,
  _swigc__p_std__unique_ptrT_lldb_private__DataExtractor_t,
  _swigc__p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t,
  _swigc__p_std__unique_ptrT_lldb_private__DynamicLoader_t,
  _swigc__p_std__unique_ptrT_lldb_private__File_t,
  _swigc__p_std__unique_ptrT_lldb_private__JITLoaderList_t,
  _swigc__p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t,
  _swigc__p_std__unique_ptrT_lldb_private__OperatingSystem_t,
  _swigc__p_std__unique_ptrT_lldb_private__ProtocolServer_t,
  _swigc__p_std__unique_ptrT_lldb_private__ScriptedPlatformInterface_t,
  _swigc__p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t,
  _swigc__p_std__unique_ptrT_lldb_private__SectionList_t,
  _swigc__p_std__unique_ptrT_lldb_private__SourceManager_t,
  _swigc__p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t,
  _swigc__p_std__unique_ptrT_lldb_private__Stream_t,
  _swigc__p_std__unique_ptrT_lldb_private__StructuredDataImpl_t,
  _swigc__p_std__unique_ptrT_lldb_private__SymbolVendor_t,
  _swigc__p_std__unique_ptrT_lldb_private__SystemRuntime_t,
  _swigc__p_std__unique_ptrT_lldb_private__TraceExporter_t,
  _swigc__p_std__weak_ptrT_lldb_private__BreakpointLocation_t,
  _swigc__p_std__weak_ptrT_lldb_private__Breakpoint_t,
  _swigc__p_std__weak_ptrT_lldb_private__BroadcasterManager_t,
  _swigc__p_std__weak_ptrT_lldb_private__Debugger_t,
  _swigc__p_std__weak_ptrT_lldb_private__Listener_t,
  _swigc__p_std__weak_ptrT_lldb_private__Module_t,
  _swigc__p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t,
  _swigc__p_std__weak_ptrT_lldb_private__OptionValue_t,
  _swigc__p_std__weak_ptrT_lldb_private__Process_t,
  _swigc__p_std__weak_ptrT_lldb_private__Queue_t,
  _swigc__p_std__weak_ptrT_lldb_private__Section_t,
  _swigc__p_std__weak_ptrT_lldb_private__StackFrameList_t,
  _swigc__p_std__weak_ptrT_lldb_private__StackFrame_t,
  _swigc__p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t,
  _swigc__p_std__weak_ptrT_lldb_private__Target_t,
  _swigc__p_std__weak_ptrT_lldb_private__ThreadPlan_t,
  _swigc__p_std__weak_ptrT_lldb_private__Thread_t,
  _swigc__p_std__weak_ptrT_lldb_private__TypeSystem_t,
  _swigc__p_std__weak_ptrT_lldb_private__Type_t,
  _swigc__p_std__weak_ptrT_lldb_private__UnixSignals_t,
  _swigc__p_unsigned_char,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_long_long,
  _swigc__p_unsigned_short,
  _swigc__p_void,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is made tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast dependencies. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns.
 *
 * We loop through the cast[] array associated with the type and mark casts
 * which have not been defined in previously loaded modules by assigning
 * cast pointer value to cast->next. We also hash cast->type->name string
 * and store the value in the cast->value field. If we encounter swig_cast_info
 * structure that represents a cast to self we move it to the beginning
 * of the cast array. One trick we need to do is making sure the type pointer
 * in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the list (because the cast->type) pointer will
 *     be correct.
 *
 * Once the cast array has been set up AND it does have new casts that need
 * to be added we sort non-self cast entries to move filtered out entries
 * to the end of the array and to arrange the rest in the increasing order
 * of their type pointer values. We store the index of the last added entry
 * in the cast->value field of the entry[0] (overwriting the name hash). Then
 * we sort <next|value> fields of the remaining entries to arrange hash values
 * in the increasing order. This way cast->next->type->name field matches
 * the cast->value hash.
 *
 * Example:
 * Array of casts for type stored at 0x5000, cast to type stored at 0x3000
 * has already been loaded
 *
 *      After sweep-and-hash:   After sort-by-type:    After sort-by-hash:
 *        ________________       ________________       ________________
 *       |                |     |                |     |                |
 * Entry |  type = 0x5000 |     |  type = 0x5000 |     |  type = 0x5000 |
 *   0   |                |     |                |     |                |
 *       |  next = Entry0 |     |  next = Entry0 |     |  next = Entry0 |
 *       | value = 1212   |     | value = 3      |     | value = 3      |
 *       |                |     |                |     |                |
 *       |================|     |================|     |================|
 *       |                |     |                |     |                |
 * Entry |  type = 0x2000 |     |  type = 0x1000 |     |  type = 0x1000 |
 *   1   |                |     |                |     |                |
 *       |  next = Entry1 |     |  next = Entry1 |     |  next = Entry3 |
 *       | value = 3434   |     | value = 4545   |     | value = 2323   |
 *       |________________|     |________________|     |________________|
 *       |                |     |                |     |                |
 * Entry |  type = 0x3000 |     |  type = 0x2000 |     |  type = 0x2000 |
 *   2   |                |     |                |     |                |
 *       |  next = 0      |     |  next = Entry2 |     |  next = Entry2 |
 *       | value = 0      |     | value = 3434   |     | value = 3434   |
 *       |________________|     |________________|     |________________|
 *       |                |     |                |     |                |
 * Entry |  type = 0x1000 |     |  type = 0x4000 |     |  type = 0x4000 |
 *   3   |                |     |                |     |                |
 *       |  next = Entry3 |     |  next = Entry3 |     |  next = Entry1 |
 *       | value = 4545   |     | value = 2323   |     | value = 4545   |
 *       |________________|     |________________|     |________________|
 *       |                |     |                |     |                |
 * Entry |  type = 0x4000 |     |  type = 0x3000 |     |  type = 0x3000 |
 *   4   |                |     |                |     |                |
 *       |  next = Entry4 |     |  next = 0      |     |  next = 0      |
 *       | value = 2323   |     | value = 0      |     | value = 0      |
 *       |________________|     |________________|     |________________|
 *
 * Once the cast array has been initialized, we use cast[0]->next field to link
 * it into the list of cast arrays for the type.
 *              ____    ____    ____
 * type->cast->|next|->|next|->|next|->0
 *             |----|  |----|  |----|
 *             |----|  |----|  |----|
 *             |----|  |----|  |----|
 *
 * Subsequent cast resolution works as follows:
 *
 * 1. Check whether the type matches the first entry in the current cast array.
 * 2. If not, then do a binary search over the (0:cast->value] interval using
 *    either type address or the hash value of the type name.
 * 3. If not found, then move over to the next cast array (cast[0]->next).
 *
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif

#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif

/*
 * Sort function that puts cast entries with nonzero 'next' at the front
 * of the array while ordering them by addresses of their 'type' structs.
 */
SWIGINTERN int SWIG_CastCmpStruct(const void *pa, const void *pb) {
  swig_cast_info *pca = (swig_cast_info *)pa;
  swig_cast_info *pcb = (swig_cast_info *)pb;
  if (pca->type < pcb->type)
  return (pca->next || pcb->next == 0) ? -1 : 1;
  if (pca->type > pcb->type)
  return (pcb->next || pca->next == 0) ? 1 : -1;
  return 0;
}

/*
 * Shell-sort 'next' and 'value' field pairs to order them by 'value'.
 */
SWIGINTERN void SWIG_CastHashSort(swig_cast_info *cast, int size) {
  const int hmax = size/9;
  int h, i;
  for(h = 1; h <= hmax; h = 3*h+1);
  for(; h > 0; h /= 3)
  {
    for(i = h; i < size; ++i)
    {
      swig_cast_info *p = cast[i].next;
      unsigned int hash = cast[i].value;
      int j = i;
      while(j >= h && hash < cast[j-h].value)
      {
        cast[j].next = cast[j-h].next;
        cast[j].value = cast[j-h].value;
        j -= h;
      }
      cast[j].next = p;
      cast[j].value = hash;
    }
  }
}

SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;
  
  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }
  
  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
  if (init == 0) return;
  
  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *target_type;
    swig_cast_info *cast, *first;
    int num_mapped = 0;
    
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
    
    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
        type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }
    
    /* Insert casting types */
    cast = first = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      target_type = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        target_type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
        if (target_type) {
          /* Target type already defined in another module */
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: found cast %s\n", target_type->name);
#endif
          if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
            printf("SWIG_InitializeModule: skip old type %s\n", target_type->name);
#endif
            cast->type = target_type;
            target_type = 0;
          } else {
            /* Check if this cast is already in the list */
            swig_cast_info *ocast = SWIG_TypeCheck(target_type->name, type);
#ifdef SWIGRUNTIME_DEBUG
            if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", target_type->name);
#endif
            if (!ocast) target_type = 0;
          }
        }
      }
      
      if (!target_type) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        /* Set inclusion mark for sorting */
        cast->next = cast;
        num_mapped++;
        
        if (type == cast->type) {
#ifdef SWIGRUNTIME_DEBUG
          printf("%s : self cast at pos [%li]\n", type->name, cast - first);
#endif
          if (cast - first) {
            /* Move cast to itself to the first entry in the array */
            
            swig_cast_info tmp = *cast;
            *cast = *first;
            *first = tmp;
          }
          first++;
          
        } else {
          cast->value = SWIG_Hash(cast->type->name, (unsigned int)strlen(cast->type->name));
        }
      }
      cast++;
    }
    
    if (num_mapped) {
      if (cast - first) {
        swig_cast_info *tmp;
        
        /* Sort casts by type address for binary search in SWIG_TypeCheckStruct */
        qsort(first, cast - first, sizeof(swig_cast_info), SWIG_CastCmpStruct);
        
        /* Remap back links for added entries */
        cast = swig_module.cast_initial[i] + num_mapped;
        for (tmp = first; tmp < cast; tmp++) {
          tmp->next = tmp;
        }
      }
      
      /* Set the value field of the first entry to the index of the last added entry */
      cast = swig_module.cast_initial[i];
      cast->value = num_mapped - 1;
      
      num_mapped -= (int)(first - cast);
      if (num_mapped > 1) {
        /* Sort <'next','value'> pairs by 'value' for binary search in SWIG_TypeCheck */
        
        SWIG_CastHashSort(first, num_mapped);
      }
      
      first = type->cast;
      if (first) {
        /* Link the current set into the list of cast arrays */
        cast->next = first->next;
        first->next = cast;
      } else {
        cast->next = 0;
        type->cast = cast;
      }
    }
    
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;
  
#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
    printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  static int init_run = 0;
  
  if (init_run) return;
  init_run = 1;
  
  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      swig_cast_info *head, *cast;
      head = swig_module.types[i]->cast;
      while (head) {
        for (cast = head; (cast - head) <= head->value; cast++) {
          if (!cast->converter) {
            if (cast->type && !cast->type->clientdata)
            SWIG_TypeClientData(cast->type, swig_module.types[i]->clientdata);
          }
        }
        head = head->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{
  /* c-mode */
#endif
}
#endif



#ifdef __cplusplus
extern "C" {
#endif
  
  /* -----------------------------------------------------------------------------
   * constants/methods manipulation
   * ----------------------------------------------------------------------------- */
  
  /* Install Constants */
  SWIGINTERN void
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
    PyObject *obj = 0;
    size_t i;
    for (i = 0; constants[i].type; ++i) {
      switch(constants[i].type) {
      case SWIG_PY_POINTER:
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
        break;
      case SWIG_PY_BINARY:
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
        break;
      default:
        obj = 0;
        break;
      }
      if (obj) {
        PyDict_SetItemString(d, constants[i].name, obj);
        SWIG_Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------
   * Patch %callback methods' docstrings to hold the callback ptrs
   * -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
    size_t i;
    for (i = 0; methods[i].ml_name; ++i) {
      const char *c = methods[i].ml_doc;
      if (!c) continue;
      c = strstr(c, "swig_ptr: ");
      if (c) {
        int j;
        const swig_const_info *ci = 0;
        const char *name = c + 10;
        for (j = 0; const_table[j].type; ++j) {
          if (strncmp(const_table[j].name, name, 
              strlen(const_table[j].name)) == 0) {
            ci = &(const_table[j]);
            break;
          }
        }
        if (ci) {
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
          if (ptr) {
            size_t shift = (ci->ptype) - types;
            swig_type_info *ty = types_initial[shift];
            size_t ldoc = (c - methods[i].ml_doc);
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
            if (ndoc) {
              char *buff = ndoc;
              memcpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              memcpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
#ifdef __cplusplus
}
#endif




/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

SWIGINTERN int SWIG_mod_exec(PyObject *module);

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
#if PY_VERSION_HEX >= 0x03000000
  static PyModuleDef_Slot SwigSlots[] = {
    {
      Py_mod_exec, (void *)SWIG_mod_exec 
    },
#ifdef SWIGPYTHON_NOGIL
#ifdef Py_GIL_DISABLED
    {
      Py_mod_gil, Py_MOD_GIL_NOT_USED 
    },
#endif
#endif
    {
      0, NULL 
    }
  };
  
  static struct PyModuleDef SWIG_module = {
    PyModuleDef_HEAD_INIT,
    SWIG_name,
    NULL,
    0,
    SwigMethods,
    SwigSlots,
    NULL,
    NULL,
    NULL
  };
  
  return PyModuleDef_Init(&SWIG_module);
#else
  PyObject *m = Py_InitModule(SWIG_name, SwigMethods);
  if (m && SWIG_mod_exec(m) != 0) {
    Py_DECREF(m);
  }
#endif
}

SWIGINTERN int SWIG_mod_exec(PyObject *m) {
  PyObject *d, *md, *globals;
  
#if defined(SWIGPYTHON_BUILTIN)
  static SwigPyClientData SwigPyObject_clientdata = {
    0, 0, 0, 0, 0, 0, 0
  };
  static PyGetSetDef this_getset_def = {
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
  };
  static SwigPyGetSet thisown_getset_closure = {
    SwigPyObject_own,
    SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  PyTypeObject *swigpyobject;
  SwigPyClientData *cd;
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
  PyObject *self = 0;
  int i;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  (void)self;
  
  /* Metaclass is used to implement static member variables */
  metatype = SwigPyObjectType_Type();
  assert(metatype);
  
  SwigPyStaticVar_Type();
#endif
  
  (void)globals;
  
  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
  SWIG_runtime_data_module();
  SWIG_This();
  SWIG_Python_TypeCache();
  SwigPyPacked_Type();
  SwigVarLink_Type();
#ifndef SWIGPYTHON_BUILTIN
  SwigPyObject_Type();
#endif
  
  /* Fix SwigMethods to carry the callback ptrs when needed */
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
  
#ifdef SWIGPYTHON_NOGIL
#ifdef Py_GIL_DISABLED
  PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
#endif
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  swigpyobject = SwigPyObject_TypeOnce();
  
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
  assert(SwigPyObject_stype);
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
  if (!cd) {
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
    SwigPyObject_clientdata.pytype = swigpyobject;
  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
    return -1;
  }
  
  /* All objects have a 'this' attribute */
  this_descr = PyDescr_NewGetSet(SwigPyObject_Type(), &this_getset_def);
  (void)this_descr;
  
  /* All objects have a 'thisown' attribute */
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_Type(), &thisown_getset_def);
  (void)thisown_descr;
  
  public_interface = PyList_New(0);
  public_symbol = 0;
  (void)public_symbol;
  
  PyDict_SetItemString(md, "__all__", public_interface);
  SWIG_Py_DECREF(public_interface);
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
  for (i = 0; swig_const_table[i].name != 0; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
  
  SWIG_InstallConstants(d,swig_const_table);
  
  SWIG_Python_SetConstant(d, "INT32_MAX",SWIG_From_int(static_cast< int >(2147483647)));
  SWIG_Python_SetConstant(d, "UINT32_MAX",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(4294967295U)));
  SWIG_Python_SetConstant(d, "UINT64_MAX",SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(18446744073709551615ULL)));
  SWIG_Python_SetConstant(d, "LLDB_GENERIC_ERROR",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(4294967295U)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_BREAK_ID",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "LLDB_DEFAULT_BREAK_SIZE",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_WATCH_ID",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "LLDB_WATCH_TYPE_READ",SWIG_From_unsigned_SS_int(static_cast< unsigned int >((1u << 0))));
  SWIG_Python_SetConstant(d, "LLDB_WATCH_TYPE_WRITE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >((1u << 1))));
  SWIG_Python_SetConstant(d, "LLDB_WATCH_TYPE_MODIFY",SWIG_From_unsigned_SS_int(static_cast< unsigned int >((1u << 2))));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_SITE_ID",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(4294967295U)));
  SWIG_Python_SetConstant(d, "LLDB_REGNUM_GENERIC_PC",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "LLDB_REGNUM_GENERIC_SP",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "LLDB_REGNUM_GENERIC_FP",SWIG_From_int(static_cast< int >(2)));
  SWIG_Python_SetConstant(d, "LLDB_REGNUM_GENERIC_RA",SWIG_From_int(static_cast< int >(3)));
  SWIG_Python_SetConstant(d, "LLDB_REGNUM_GENERIC_FLAGS",SWIG_From_int(static_cast< int >(4)));
  SWIG_Python_SetConstant(d, "LLDB_REGNUM_GENERIC_ARG1",SWIG_From_int(static_cast< int >(5)));
  SWIG_Python_SetConstant(d, "LLDB_REGNUM_GENERIC_ARG2",SWIG_From_int(static_cast< int >(6)));
  SWIG_Python_SetConstant(d, "LLDB_REGNUM_GENERIC_ARG3",SWIG_From_int(static_cast< int >(7)));
  SWIG_Python_SetConstant(d, "LLDB_REGNUM_GENERIC_ARG4",SWIG_From_int(static_cast< int >(8)));
  SWIG_Python_SetConstant(d, "LLDB_REGNUM_GENERIC_ARG5",SWIG_From_int(static_cast< int >(9)));
  SWIG_Python_SetConstant(d, "LLDB_REGNUM_GENERIC_ARG6",SWIG_From_int(static_cast< int >(10)));
  SWIG_Python_SetConstant(d, "LLDB_REGNUM_GENERIC_ARG7",SWIG_From_int(static_cast< int >(11)));
  SWIG_Python_SetConstant(d, "LLDB_REGNUM_GENERIC_ARG8",SWIG_From_int(static_cast< int >(12)));
  SWIG_Python_SetConstant(d, "LLDB_REGNUM_GENERIC_TP",SWIG_From_int(static_cast< int >(13)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_STOP_ID",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_ADDRESS",SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(18446744073709551615ULL)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_INDEX32",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(4294967295U)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_IVAR_OFFSET",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(4294967295U)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_IMAGE_TOKEN",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(4294967295U)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_MODULE_VERSION",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(4294967295U)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_REGNUM",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(4294967295U)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_UID",SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(18446744073709551615ULL)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_PROCESS_ID",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_THREAD_ID",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_FRAME_ID",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(4294967295U)));
  SWIG_Python_SetConstant(d, "LLDB_UNWINDER_FRAME_LIST_ID",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_SIGNAL_NUMBER",SWIG_From_int(static_cast< int >(2147483647)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_SYMBOL_ID",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(4294967295U)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_OFFSET",SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(18446744073709551615ULL)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_LINE_NUMBER",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(4294967295U)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_COLUMN_NUMBER",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_QUEUE_ID",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_CPU_ID",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(4294967295U)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_WATCHPOINT_RESOURCE_ID",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(4294967295U)));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_GLOBALLY_UNIQUE_TARGET_ID",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "LLDB_ARCH_DEFAULT",SWIG_FromCharPtr("systemArch"));
  SWIG_Python_SetConstant(d, "LLDB_ARCH_DEFAULT_32BIT",SWIG_FromCharPtr("systemArch32"));
  SWIG_Python_SetConstant(d, "LLDB_ARCH_DEFAULT_64BIT",SWIG_FromCharPtr("systemArch64"));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_CPUTYPE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >((0xFFFFFFFEu))));
  SWIG_Python_SetConstant(d, "LLDB_MAX_NUM_OPTION_SETS",SWIG_From_int(static_cast< int >(32)));
  SWIG_Python_SetConstant(d, "LLDB_OPT_SET_ALL",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(0xFFFFFFFFU)));
  SWIG_Python_SetConstant(d, "LLDB_OPT_SET_1",SWIG_From_unsigned_SS_int(static_cast< unsigned int >((1U << 0))));
  SWIG_Python_SetConstant(d, "LLDB_OPT_SET_2",SWIG_From_unsigned_SS_int(static_cast< unsigned int >((1U << 1))));
  SWIG_Python_SetConstant(d, "LLDB_OPT_SET_3",SWIG_From_unsigned_SS_int(static_cast< unsigned int >((1U << 2))));
  SWIG_Python_SetConstant(d, "LLDB_OPT_SET_4",SWIG_From_unsigned_SS_int(static_cast< unsigned int >((1U << 3))));
  SWIG_Python_SetConstant(d, "LLDB_OPT_SET_5",SWIG_From_unsigned_SS_int(static_cast< unsigned int >((1U << 4))));
  SWIG_Python_SetConstant(d, "LLDB_OPT_SET_6",SWIG_From_unsigned_SS_int(static_cast< unsigned int >((1U << 5))));
  SWIG_Python_SetConstant(d, "LLDB_OPT_SET_7",SWIG_From_unsigned_SS_int(static_cast< unsigned int >((1U << 6))));
  SWIG_Python_SetConstant(d, "LLDB_OPT_SET_8",SWIG_From_unsigned_SS_int(static_cast< unsigned int >((1U << 7))));
  SWIG_Python_SetConstant(d, "LLDB_OPT_SET_9",SWIG_From_unsigned_SS_int(static_cast< unsigned int >((1U << 8))));
  SWIG_Python_SetConstant(d, "LLDB_OPT_SET_10",SWIG_From_unsigned_SS_int(static_cast< unsigned int >((1U << 9))));
  SWIG_Python_SetConstant(d, "LLDB_OPT_SET_11",SWIG_From_unsigned_SS_int(static_cast< unsigned int >((1U << 10))));
  SWIG_Python_SetConstant(d, "LLDB_OPT_SET_12",SWIG_From_unsigned_SS_int(static_cast< unsigned int >((1U << 11))));
  SWIG_Python_SetConstant(d, "LLDB_INVALID_ADDRESS_MASK",SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(18446744073709551615ULL)));
  SWIG_Python_SetConstant(d, "eStateInvalid",SWIG_From_int(static_cast< int >(lldb::eStateInvalid)));
  SWIG_Python_SetConstant(d, "eStateUnloaded",SWIG_From_int(static_cast< int >(lldb::eStateUnloaded)));
  SWIG_Python_SetConstant(d, "eStateConnected",SWIG_From_int(static_cast< int >(lldb::eStateConnected)));
  SWIG_Python_SetConstant(d, "eStateAttaching",SWIG_From_int(static_cast< int >(lldb::eStateAttaching)));
  SWIG_Python_SetConstant(d, "eStateLaunching",SWIG_From_int(static_cast< int >(lldb::eStateLaunching)));
  SWIG_Python_SetConstant(d, "eStateStopped",SWIG_From_int(static_cast< int >(lldb::eStateStopped)));
  SWIG_Python_SetConstant(d, "eStateRunning",SWIG_From_int(static_cast< int >(lldb::eStateRunning)));
  SWIG_Python_SetConstant(d, "eStateStepping",SWIG_From_int(static_cast< int >(lldb::eStateStepping)));
  SWIG_Python_SetConstant(d, "eStateCrashed",SWIG_From_int(static_cast< int >(lldb::eStateCrashed)));
  SWIG_Python_SetConstant(d, "eStateDetached",SWIG_From_int(static_cast< int >(lldb::eStateDetached)));
  SWIG_Python_SetConstant(d, "eStateExited",SWIG_From_int(static_cast< int >(lldb::eStateExited)));
  SWIG_Python_SetConstant(d, "eStateSuspended",SWIG_From_int(static_cast< int >(lldb::eStateSuspended)));
  SWIG_Python_SetConstant(d, "kLastStateType",SWIG_From_int(static_cast< int >(lldb::kLastStateType)));
  SWIG_Python_SetConstant(d, "eLaunchFlagNone",SWIG_From_int(static_cast< int >(lldb::eLaunchFlagNone)));
  SWIG_Python_SetConstant(d, "eLaunchFlagExec",SWIG_From_int(static_cast< int >(lldb::eLaunchFlagExec)));
  SWIG_Python_SetConstant(d, "eLaunchFlagDebug",SWIG_From_int(static_cast< int >(lldb::eLaunchFlagDebug)));
  SWIG_Python_SetConstant(d, "eLaunchFlagStopAtEntry",SWIG_From_int(static_cast< int >(lldb::eLaunchFlagStopAtEntry)));
  SWIG_Python_SetConstant(d, "eLaunchFlagDisableASLR",SWIG_From_int(static_cast< int >(lldb::eLaunchFlagDisableASLR)));
  SWIG_Python_SetConstant(d, "eLaunchFlagDisableSTDIO",SWIG_From_int(static_cast< int >(lldb::eLaunchFlagDisableSTDIO)));
  SWIG_Python_SetConstant(d, "eLaunchFlagLaunchInTTY",SWIG_From_int(static_cast< int >(lldb::eLaunchFlagLaunchInTTY)));
  SWIG_Python_SetConstant(d, "eLaunchFlagLaunchInShell",SWIG_From_int(static_cast< int >(lldb::eLaunchFlagLaunchInShell)));
  SWIG_Python_SetConstant(d, "eLaunchFlagLaunchInSeparateProcessGroup",SWIG_From_int(static_cast< int >(lldb::eLaunchFlagLaunchInSeparateProcessGroup)));
  SWIG_Python_SetConstant(d, "eLaunchFlagDontSetExitStatus",SWIG_From_int(static_cast< int >(lldb::eLaunchFlagDontSetExitStatus)));
  SWIG_Python_SetConstant(d, "eLaunchFlagDetachOnError",SWIG_From_int(static_cast< int >(lldb::eLaunchFlagDetachOnError)));
  SWIG_Python_SetConstant(d, "eLaunchFlagShellExpandArguments",SWIG_From_int(static_cast< int >(lldb::eLaunchFlagShellExpandArguments)));
  SWIG_Python_SetConstant(d, "eLaunchFlagCloseTTYOnExit",SWIG_From_int(static_cast< int >(lldb::eLaunchFlagCloseTTYOnExit)));
  SWIG_Python_SetConstant(d, "eLaunchFlagInheritTCCFromParent",SWIG_From_int(static_cast< int >(lldb::eLaunchFlagInheritTCCFromParent)));
  SWIG_Python_SetConstant(d, "eLaunchFlagMemoryTagging",SWIG_From_int(static_cast< int >(lldb::eLaunchFlagMemoryTagging)));
  SWIG_Python_SetConstant(d, "eOnlyThisThread",SWIG_From_int(static_cast< int >(lldb::eOnlyThisThread)));
  SWIG_Python_SetConstant(d, "eAllThreads",SWIG_From_int(static_cast< int >(lldb::eAllThreads)));
  SWIG_Python_SetConstant(d, "eOnlyDuringStepping",SWIG_From_int(static_cast< int >(lldb::eOnlyDuringStepping)));
  SWIG_Python_SetConstant(d, "eRunForward",SWIG_From_int(static_cast< int >(lldb::eRunForward)));
  SWIG_Python_SetConstant(d, "eRunReverse",SWIG_From_int(static_cast< int >(lldb::eRunReverse)));
  SWIG_Python_SetConstant(d, "eByteOrderInvalid",SWIG_From_int(static_cast< int >(lldb::eByteOrderInvalid)));
  SWIG_Python_SetConstant(d, "eByteOrderBig",SWIG_From_int(static_cast< int >(lldb::eByteOrderBig)));
  SWIG_Python_SetConstant(d, "eByteOrderPDP",SWIG_From_int(static_cast< int >(lldb::eByteOrderPDP)));
  SWIG_Python_SetConstant(d, "eByteOrderLittle",SWIG_From_int(static_cast< int >(lldb::eByteOrderLittle)));
  SWIG_Python_SetConstant(d, "eEncodingInvalid",SWIG_From_int(static_cast< int >(lldb::eEncodingInvalid)));
  SWIG_Python_SetConstant(d, "eEncodingUint",SWIG_From_int(static_cast< int >(lldb::eEncodingUint)));
  SWIG_Python_SetConstant(d, "eEncodingSint",SWIG_From_int(static_cast< int >(lldb::eEncodingSint)));
  SWIG_Python_SetConstant(d, "eEncodingIEEE754",SWIG_From_int(static_cast< int >(lldb::eEncodingIEEE754)));
  SWIG_Python_SetConstant(d, "eEncodingVector",SWIG_From_int(static_cast< int >(lldb::eEncodingVector)));
  SWIG_Python_SetConstant(d, "eFormatDefault",SWIG_From_int(static_cast< int >(lldb::eFormatDefault)));
  SWIG_Python_SetConstant(d, "eFormatInvalid",SWIG_From_int(static_cast< int >(lldb::eFormatInvalid)));
  SWIG_Python_SetConstant(d, "eFormatBoolean",SWIG_From_int(static_cast< int >(lldb::eFormatBoolean)));
  SWIG_Python_SetConstant(d, "eFormatBinary",SWIG_From_int(static_cast< int >(lldb::eFormatBinary)));
  SWIG_Python_SetConstant(d, "eFormatBytes",SWIG_From_int(static_cast< int >(lldb::eFormatBytes)));
  SWIG_Python_SetConstant(d, "eFormatBytesWithASCII",SWIG_From_int(static_cast< int >(lldb::eFormatBytesWithASCII)));
  SWIG_Python_SetConstant(d, "eFormatChar",SWIG_From_int(static_cast< int >(lldb::eFormatChar)));
  SWIG_Python_SetConstant(d, "eFormatCharPrintable",SWIG_From_int(static_cast< int >(lldb::eFormatCharPrintable)));
  SWIG_Python_SetConstant(d, "eFormatComplex",SWIG_From_int(static_cast< int >(lldb::eFormatComplex)));
  SWIG_Python_SetConstant(d, "eFormatComplexFloat",SWIG_From_int(static_cast< int >(lldb::eFormatComplexFloat)));
  SWIG_Python_SetConstant(d, "eFormatCString",SWIG_From_int(static_cast< int >(lldb::eFormatCString)));
  SWIG_Python_SetConstant(d, "eFormatDecimal",SWIG_From_int(static_cast< int >(lldb::eFormatDecimal)));
  SWIG_Python_SetConstant(d, "eFormatEnum",SWIG_From_int(static_cast< int >(lldb::eFormatEnum)));
  SWIG_Python_SetConstant(d, "eFormatHex",SWIG_From_int(static_cast< int >(lldb::eFormatHex)));
  SWIG_Python_SetConstant(d, "eFormatHexUppercase",SWIG_From_int(static_cast< int >(lldb::eFormatHexUppercase)));
  SWIG_Python_SetConstant(d, "eFormatFloat",SWIG_From_int(static_cast< int >(lldb::eFormatFloat)));
  SWIG_Python_SetConstant(d, "eFormatOctal",SWIG_From_int(static_cast< int >(lldb::eFormatOctal)));
  SWIG_Python_SetConstant(d, "eFormatOSType",SWIG_From_int(static_cast< int >(lldb::eFormatOSType)));
  SWIG_Python_SetConstant(d, "eFormatUnicode16",SWIG_From_int(static_cast< int >(lldb::eFormatUnicode16)));
  SWIG_Python_SetConstant(d, "eFormatUnicode32",SWIG_From_int(static_cast< int >(lldb::eFormatUnicode32)));
  SWIG_Python_SetConstant(d, "eFormatUnsigned",SWIG_From_int(static_cast< int >(lldb::eFormatUnsigned)));
  SWIG_Python_SetConstant(d, "eFormatPointer",SWIG_From_int(static_cast< int >(lldb::eFormatPointer)));
  SWIG_Python_SetConstant(d, "eFormatVectorOfChar",SWIG_From_int(static_cast< int >(lldb::eFormatVectorOfChar)));
  SWIG_Python_SetConstant(d, "eFormatVectorOfSInt8",SWIG_From_int(static_cast< int >(lldb::eFormatVectorOfSInt8)));
  SWIG_Python_SetConstant(d, "eFormatVectorOfUInt8",SWIG_From_int(static_cast< int >(lldb::eFormatVectorOfUInt8)));
  SWIG_Python_SetConstant(d, "eFormatVectorOfSInt16",SWIG_From_int(static_cast< int >(lldb::eFormatVectorOfSInt16)));
  SWIG_Python_SetConstant(d, "eFormatVectorOfUInt16",SWIG_From_int(static_cast< int >(lldb::eFormatVectorOfUInt16)));
  SWIG_Python_SetConstant(d, "eFormatVectorOfSInt32",SWIG_From_int(static_cast< int >(lldb::eFormatVectorOfSInt32)));
  SWIG_Python_SetConstant(d, "eFormatVectorOfUInt32",SWIG_From_int(static_cast< int >(lldb::eFormatVectorOfUInt32)));
  SWIG_Python_SetConstant(d, "eFormatVectorOfSInt64",SWIG_From_int(static_cast< int >(lldb::eFormatVectorOfSInt64)));
  SWIG_Python_SetConstant(d, "eFormatVectorOfUInt64",SWIG_From_int(static_cast< int >(lldb::eFormatVectorOfUInt64)));
  SWIG_Python_SetConstant(d, "eFormatVectorOfFloat16",SWIG_From_int(static_cast< int >(lldb::eFormatVectorOfFloat16)));
  SWIG_Python_SetConstant(d, "eFormatVectorOfFloat32",SWIG_From_int(static_cast< int >(lldb::eFormatVectorOfFloat32)));
  SWIG_Python_SetConstant(d, "eFormatVectorOfFloat64",SWIG_From_int(static_cast< int >(lldb::eFormatVectorOfFloat64)));
  SWIG_Python_SetConstant(d, "eFormatVectorOfUInt128",SWIG_From_int(static_cast< int >(lldb::eFormatVectorOfUInt128)));
  SWIG_Python_SetConstant(d, "eFormatComplexInteger",SWIG_From_int(static_cast< int >(lldb::eFormatComplexInteger)));
  SWIG_Python_SetConstant(d, "eFormatCharArray",SWIG_From_int(static_cast< int >(lldb::eFormatCharArray)));
  SWIG_Python_SetConstant(d, "eFormatAddressInfo",SWIG_From_int(static_cast< int >(lldb::eFormatAddressInfo)));
  SWIG_Python_SetConstant(d, "eFormatHexFloat",SWIG_From_int(static_cast< int >(lldb::eFormatHexFloat)));
  SWIG_Python_SetConstant(d, "eFormatInstruction",SWIG_From_int(static_cast< int >(lldb::eFormatInstruction)));
  SWIG_Python_SetConstant(d, "eFormatVoid",SWIG_From_int(static_cast< int >(lldb::eFormatVoid)));
  SWIG_Python_SetConstant(d, "eFormatUnicode8",SWIG_From_int(static_cast< int >(lldb::eFormatUnicode8)));
  SWIG_Python_SetConstant(d, "eFormatFloat128",SWIG_From_int(static_cast< int >(lldb::eFormatFloat128)));
  SWIG_Python_SetConstant(d, "kNumFormats",SWIG_From_int(static_cast< int >(lldb::kNumFormats)));
  SWIG_Python_SetConstant(d, "eDescriptionLevelBrief",SWIG_From_int(static_cast< int >(lldb::eDescriptionLevelBrief)));
  SWIG_Python_SetConstant(d, "eDescriptionLevelFull",SWIG_From_int(static_cast< int >(lldb::eDescriptionLevelFull)));
  SWIG_Python_SetConstant(d, "eDescriptionLevelVerbose",SWIG_From_int(static_cast< int >(lldb::eDescriptionLevelVerbose)));
  SWIG_Python_SetConstant(d, "eDescriptionLevelInitial",SWIG_From_int(static_cast< int >(lldb::eDescriptionLevelInitial)));
  SWIG_Python_SetConstant(d, "kNumDescriptionLevels",SWIG_From_int(static_cast< int >(lldb::kNumDescriptionLevels)));
  SWIG_Python_SetConstant(d, "eScriptLanguageNone",SWIG_From_int(static_cast< int >(lldb::eScriptLanguageNone)));
  SWIG_Python_SetConstant(d, "eScriptLanguagePython",SWIG_From_int(static_cast< int >(lldb::eScriptLanguagePython)));
  SWIG_Python_SetConstant(d, "eScriptLanguageLua",SWIG_From_int(static_cast< int >(lldb::eScriptLanguageLua)));
  SWIG_Python_SetConstant(d, "eScriptLanguageUnknown",SWIG_From_int(static_cast< int >(lldb::eScriptLanguageUnknown)));
  SWIG_Python_SetConstant(d, "eScriptLanguageDefault",SWIG_From_int(static_cast< int >(lldb::eScriptLanguageDefault)));
  SWIG_Python_SetConstant(d, "eRegisterKindEHFrame",SWIG_From_int(static_cast< int >(lldb::eRegisterKindEHFrame)));
  SWIG_Python_SetConstant(d, "eRegisterKindDWARF",SWIG_From_int(static_cast< int >(lldb::eRegisterKindDWARF)));
  SWIG_Python_SetConstant(d, "eRegisterKindGeneric",SWIG_From_int(static_cast< int >(lldb::eRegisterKindGeneric)));
  SWIG_Python_SetConstant(d, "eRegisterKindProcessPlugin",SWIG_From_int(static_cast< int >(lldb::eRegisterKindProcessPlugin)));
  SWIG_Python_SetConstant(d, "eRegisterKindLLDB",SWIG_From_int(static_cast< int >(lldb::eRegisterKindLLDB)));
  SWIG_Python_SetConstant(d, "kNumRegisterKinds",SWIG_From_int(static_cast< int >(lldb::kNumRegisterKinds)));
  SWIG_Python_SetConstant(d, "eStopReasonInvalid",SWIG_From_int(static_cast< int >(lldb::eStopReasonInvalid)));
  SWIG_Python_SetConstant(d, "eStopReasonNone",SWIG_From_int(static_cast< int >(lldb::eStopReasonNone)));
  SWIG_Python_SetConstant(d, "eStopReasonTrace",SWIG_From_int(static_cast< int >(lldb::eStopReasonTrace)));
  SWIG_Python_SetConstant(d, "eStopReasonBreakpoint",SWIG_From_int(static_cast< int >(lldb::eStopReasonBreakpoint)));
  SWIG_Python_SetConstant(d, "eStopReasonWatchpoint",SWIG_From_int(static_cast< int >(lldb::eStopReasonWatchpoint)));
  SWIG_Python_SetConstant(d, "eStopReasonSignal",SWIG_From_int(static_cast< int >(lldb::eStopReasonSignal)));
  SWIG_Python_SetConstant(d, "eStopReasonException",SWIG_From_int(static_cast< int >(lldb::eStopReasonException)));
  SWIG_Python_SetConstant(d, "eStopReasonExec",SWIG_From_int(static_cast< int >(lldb::eStopReasonExec)));
  SWIG_Python_SetConstant(d, "eStopReasonPlanComplete",SWIG_From_int(static_cast< int >(lldb::eStopReasonPlanComplete)));
  SWIG_Python_SetConstant(d, "eStopReasonThreadExiting",SWIG_From_int(static_cast< int >(lldb::eStopReasonThreadExiting)));
  SWIG_Python_SetConstant(d, "eStopReasonInstrumentation",SWIG_From_int(static_cast< int >(lldb::eStopReasonInstrumentation)));
  SWIG_Python_SetConstant(d, "eStopReasonProcessorTrace",SWIG_From_int(static_cast< int >(lldb::eStopReasonProcessorTrace)));
  SWIG_Python_SetConstant(d, "eStopReasonFork",SWIG_From_int(static_cast< int >(lldb::eStopReasonFork)));
  SWIG_Python_SetConstant(d, "eStopReasonVFork",SWIG_From_int(static_cast< int >(lldb::eStopReasonVFork)));
  SWIG_Python_SetConstant(d, "eStopReasonVForkDone",SWIG_From_int(static_cast< int >(lldb::eStopReasonVForkDone)));
  SWIG_Python_SetConstant(d, "eStopReasonInterrupt",SWIG_From_int(static_cast< int >(lldb::eStopReasonInterrupt)));
  SWIG_Python_SetConstant(d, "eStopReasonHistoryBoundary",SWIG_From_int(static_cast< int >(lldb::eStopReasonHistoryBoundary)));
  SWIG_Python_SetConstant(d, "eReturnStatusInvalid",SWIG_From_int(static_cast< int >(lldb::eReturnStatusInvalid)));
  SWIG_Python_SetConstant(d, "eReturnStatusSuccessFinishNoResult",SWIG_From_int(static_cast< int >(lldb::eReturnStatusSuccessFinishNoResult)));
  SWIG_Python_SetConstant(d, "eReturnStatusSuccessFinishResult",SWIG_From_int(static_cast< int >(lldb::eReturnStatusSuccessFinishResult)));
  SWIG_Python_SetConstant(d, "eReturnStatusSuccessContinuingNoResult",SWIG_From_int(static_cast< int >(lldb::eReturnStatusSuccessContinuingNoResult)));
  SWIG_Python_SetConstant(d, "eReturnStatusSuccessContinuingResult",SWIG_From_int(static_cast< int >(lldb::eReturnStatusSuccessContinuingResult)));
  SWIG_Python_SetConstant(d, "eReturnStatusStarted",SWIG_From_int(static_cast< int >(lldb::eReturnStatusStarted)));
  SWIG_Python_SetConstant(d, "eReturnStatusFailed",SWIG_From_int(static_cast< int >(lldb::eReturnStatusFailed)));
  SWIG_Python_SetConstant(d, "eReturnStatusQuit",SWIG_From_int(static_cast< int >(lldb::eReturnStatusQuit)));
  SWIG_Python_SetConstant(d, "eExpressionCompleted",SWIG_From_int(static_cast< int >(lldb::eExpressionCompleted)));
  SWIG_Python_SetConstant(d, "eExpressionSetupError",SWIG_From_int(static_cast< int >(lldb::eExpressionSetupError)));
  SWIG_Python_SetConstant(d, "eExpressionParseError",SWIG_From_int(static_cast< int >(lldb::eExpressionParseError)));
  SWIG_Python_SetConstant(d, "eExpressionDiscarded",SWIG_From_int(static_cast< int >(lldb::eExpressionDiscarded)));
  SWIG_Python_SetConstant(d, "eExpressionInterrupted",SWIG_From_int(static_cast< int >(lldb::eExpressionInterrupted)));
  SWIG_Python_SetConstant(d, "eExpressionHitBreakpoint",SWIG_From_int(static_cast< int >(lldb::eExpressionHitBreakpoint)));
  SWIG_Python_SetConstant(d, "eExpressionTimedOut",SWIG_From_int(static_cast< int >(lldb::eExpressionTimedOut)));
  SWIG_Python_SetConstant(d, "eExpressionResultUnavailable",SWIG_From_int(static_cast< int >(lldb::eExpressionResultUnavailable)));
  SWIG_Python_SetConstant(d, "eExpressionStoppedForDebug",SWIG_From_int(static_cast< int >(lldb::eExpressionStoppedForDebug)));
  SWIG_Python_SetConstant(d, "eExpressionThreadVanished",SWIG_From_int(static_cast< int >(lldb::eExpressionThreadVanished)));
  SWIG_Python_SetConstant(d, "eSearchDepthInvalid",SWIG_From_int(static_cast< int >(lldb::eSearchDepthInvalid)));
  SWIG_Python_SetConstant(d, "eSearchDepthTarget",SWIG_From_int(static_cast< int >(lldb::eSearchDepthTarget)));
  SWIG_Python_SetConstant(d, "eSearchDepthModule",SWIG_From_int(static_cast< int >(lldb::eSearchDepthModule)));
  SWIG_Python_SetConstant(d, "eSearchDepthCompUnit",SWIG_From_int(static_cast< int >(lldb::eSearchDepthCompUnit)));
  SWIG_Python_SetConstant(d, "eSearchDepthFunction",SWIG_From_int(static_cast< int >(lldb::eSearchDepthFunction)));
  SWIG_Python_SetConstant(d, "eSearchDepthBlock",SWIG_From_int(static_cast< int >(lldb::eSearchDepthBlock)));
  SWIG_Python_SetConstant(d, "eSearchDepthAddress",SWIG_From_int(static_cast< int >(lldb::eSearchDepthAddress)));
  SWIG_Python_SetConstant(d, "kLastSearchDepthKind",SWIG_From_int(static_cast< int >(lldb::kLastSearchDepthKind)));
  SWIG_Python_SetConstant(d, "eConnectionStatusSuccess",SWIG_From_int(static_cast< int >(lldb::eConnectionStatusSuccess)));
  SWIG_Python_SetConstant(d, "eConnectionStatusEndOfFile",SWIG_From_int(static_cast< int >(lldb::eConnectionStatusEndOfFile)));
  SWIG_Python_SetConstant(d, "eConnectionStatusError",SWIG_From_int(static_cast< int >(lldb::eConnectionStatusError)));
  SWIG_Python_SetConstant(d, "eConnectionStatusTimedOut",SWIG_From_int(static_cast< int >(lldb::eConnectionStatusTimedOut)));
  SWIG_Python_SetConstant(d, "eConnectionStatusNoConnection",SWIG_From_int(static_cast< int >(lldb::eConnectionStatusNoConnection)));
  SWIG_Python_SetConstant(d, "eConnectionStatusLostConnection",SWIG_From_int(static_cast< int >(lldb::eConnectionStatusLostConnection)));
  SWIG_Python_SetConstant(d, "eConnectionStatusInterrupted",SWIG_From_int(static_cast< int >(lldb::eConnectionStatusInterrupted)));
  SWIG_Python_SetConstant(d, "eErrorTypeInvalid",SWIG_From_int(static_cast< int >(lldb::eErrorTypeInvalid)));
  SWIG_Python_SetConstant(d, "eErrorTypeGeneric",SWIG_From_int(static_cast< int >(lldb::eErrorTypeGeneric)));
  SWIG_Python_SetConstant(d, "eErrorTypeMachKernel",SWIG_From_int(static_cast< int >(lldb::eErrorTypeMachKernel)));
  SWIG_Python_SetConstant(d, "eErrorTypePOSIX",SWIG_From_int(static_cast< int >(lldb::eErrorTypePOSIX)));
  SWIG_Python_SetConstant(d, "eErrorTypeExpression",SWIG_From_int(static_cast< int >(lldb::eErrorTypeExpression)));
  SWIG_Python_SetConstant(d, "eErrorTypeWin32",SWIG_From_int(static_cast< int >(lldb::eErrorTypeWin32)));
  SWIG_Python_SetConstant(d, "eValueTypeInvalid",SWIG_From_int(static_cast< int >(lldb::eValueTypeInvalid)));
  SWIG_Python_SetConstant(d, "eValueTypeVariableGlobal",SWIG_From_int(static_cast< int >(lldb::eValueTypeVariableGlobal)));
  SWIG_Python_SetConstant(d, "eValueTypeVariableStatic",SWIG_From_int(static_cast< int >(lldb::eValueTypeVariableStatic)));
  SWIG_Python_SetConstant(d, "eValueTypeVariableArgument",SWIG_From_int(static_cast< int >(lldb::eValueTypeVariableArgument)));
  SWIG_Python_SetConstant(d, "eValueTypeVariableLocal",SWIG_From_int(static_cast< int >(lldb::eValueTypeVariableLocal)));
  SWIG_Python_SetConstant(d, "eValueTypeRegister",SWIG_From_int(static_cast< int >(lldb::eValueTypeRegister)));
  SWIG_Python_SetConstant(d, "eValueTypeRegisterSet",SWIG_From_int(static_cast< int >(lldb::eValueTypeRegisterSet)));
  SWIG_Python_SetConstant(d, "eValueTypeConstResult",SWIG_From_int(static_cast< int >(lldb::eValueTypeConstResult)));
  SWIG_Python_SetConstant(d, "eValueTypeVariableThreadLocal",SWIG_From_int(static_cast< int >(lldb::eValueTypeVariableThreadLocal)));
  SWIG_Python_SetConstant(d, "eValueTypeVTable",SWIG_From_int(static_cast< int >(lldb::eValueTypeVTable)));
  SWIG_Python_SetConstant(d, "eValueTypeVTableEntry",SWIG_From_int(static_cast< int >(lldb::eValueTypeVTableEntry)));
  SWIG_Python_SetConstant(d, "eInputReaderGranularityInvalid",SWIG_From_int(static_cast< int >(lldb::eInputReaderGranularityInvalid)));
  SWIG_Python_SetConstant(d, "eInputReaderGranularityByte",SWIG_From_int(static_cast< int >(lldb::eInputReaderGranularityByte)));
  SWIG_Python_SetConstant(d, "eInputReaderGranularityWord",SWIG_From_int(static_cast< int >(lldb::eInputReaderGranularityWord)));
  SWIG_Python_SetConstant(d, "eInputReaderGranularityLine",SWIG_From_int(static_cast< int >(lldb::eInputReaderGranularityLine)));
  SWIG_Python_SetConstant(d, "eInputReaderGranularityAll",SWIG_From_int(static_cast< int >(lldb::eInputReaderGranularityAll)));
  SWIG_Python_SetConstant(d, "eSymbolContextTarget",SWIG_From_int(static_cast< int >(lldb::eSymbolContextTarget)));
  SWIG_Python_SetConstant(d, "eSymbolContextModule",SWIG_From_int(static_cast< int >(lldb::eSymbolContextModule)));
  SWIG_Python_SetConstant(d, "eSymbolContextCompUnit",SWIG_From_int(static_cast< int >(lldb::eSymbolContextCompUnit)));
  SWIG_Python_SetConstant(d, "eSymbolContextFunction",SWIG_From_int(static_cast< int >(lldb::eSymbolContextFunction)));
  SWIG_Python_SetConstant(d, "eSymbolContextBlock",SWIG_From_int(static_cast< int >(lldb::eSymbolContextBlock)));
  SWIG_Python_SetConstant(d, "eSymbolContextLineEntry",SWIG_From_int(static_cast< int >(lldb::eSymbolContextLineEntry)));
  SWIG_Python_SetConstant(d, "eSymbolContextSymbol",SWIG_From_int(static_cast< int >(lldb::eSymbolContextSymbol)));
  SWIG_Python_SetConstant(d, "eSymbolContextEverything",SWIG_From_int(static_cast< int >(lldb::eSymbolContextEverything)));
  SWIG_Python_SetConstant(d, "eSymbolContextVariable",SWIG_From_int(static_cast< int >(lldb::eSymbolContextVariable)));
  SWIG_Python_SetConstant(d, "eSymbolContextLastItem",SWIG_From_int(static_cast< int >(lldb::eSymbolContextLastItem)));
  SWIG_Python_SetConstant(d, "ePermissionsWritable",SWIG_From_int(static_cast< int >(lldb::ePermissionsWritable)));
  SWIG_Python_SetConstant(d, "ePermissionsReadable",SWIG_From_int(static_cast< int >(lldb::ePermissionsReadable)));
  SWIG_Python_SetConstant(d, "ePermissionsExecutable",SWIG_From_int(static_cast< int >(lldb::ePermissionsExecutable)));
  SWIG_Python_SetConstant(d, "eInputReaderActivate",SWIG_From_int(static_cast< int >(lldb::eInputReaderActivate)));
  SWIG_Python_SetConstant(d, "eInputReaderAsynchronousOutputWritten",SWIG_From_int(static_cast< int >(lldb::eInputReaderAsynchronousOutputWritten)));
  SWIG_Python_SetConstant(d, "eInputReaderReactivate",SWIG_From_int(static_cast< int >(lldb::eInputReaderReactivate)));
  SWIG_Python_SetConstant(d, "eInputReaderDeactivate",SWIG_From_int(static_cast< int >(lldb::eInputReaderDeactivate)));
  SWIG_Python_SetConstant(d, "eInputReaderGotToken",SWIG_From_int(static_cast< int >(lldb::eInputReaderGotToken)));
  SWIG_Python_SetConstant(d, "eInputReaderInterrupt",SWIG_From_int(static_cast< int >(lldb::eInputReaderInterrupt)));
  SWIG_Python_SetConstant(d, "eInputReaderEndOfFile",SWIG_From_int(static_cast< int >(lldb::eInputReaderEndOfFile)));
  SWIG_Python_SetConstant(d, "eInputReaderDone",SWIG_From_int(static_cast< int >(lldb::eInputReaderDone)));
  SWIG_Python_SetConstant(d, "eBreakpointEventTypeInvalidType",SWIG_From_int(static_cast< int >(lldb::eBreakpointEventTypeInvalidType)));
  SWIG_Python_SetConstant(d, "eBreakpointEventTypeAdded",SWIG_From_int(static_cast< int >(lldb::eBreakpointEventTypeAdded)));
  SWIG_Python_SetConstant(d, "eBreakpointEventTypeRemoved",SWIG_From_int(static_cast< int >(lldb::eBreakpointEventTypeRemoved)));
  SWIG_Python_SetConstant(d, "eBreakpointEventTypeLocationsAdded",SWIG_From_int(static_cast< int >(lldb::eBreakpointEventTypeLocationsAdded)));
  SWIG_Python_SetConstant(d, "eBreakpointEventTypeLocationsRemoved",SWIG_From_int(static_cast< int >(lldb::eBreakpointEventTypeLocationsRemoved)));
  SWIG_Python_SetConstant(d, "eBreakpointEventTypeLocationsResolved",SWIG_From_int(static_cast< int >(lldb::eBreakpointEventTypeLocationsResolved)));
  SWIG_Python_SetConstant(d, "eBreakpointEventTypeEnabled",SWIG_From_int(static_cast< int >(lldb::eBreakpointEventTypeEnabled)));
  SWIG_Python_SetConstant(d, "eBreakpointEventTypeDisabled",SWIG_From_int(static_cast< int >(lldb::eBreakpointEventTypeDisabled)));
  SWIG_Python_SetConstant(d, "eBreakpointEventTypeCommandChanged",SWIG_From_int(static_cast< int >(lldb::eBreakpointEventTypeCommandChanged)));
  SWIG_Python_SetConstant(d, "eBreakpointEventTypeConditionChanged",SWIG_From_int(static_cast< int >(lldb::eBreakpointEventTypeConditionChanged)));
  SWIG_Python_SetConstant(d, "eBreakpointEventTypeIgnoreChanged",SWIG_From_int(static_cast< int >(lldb::eBreakpointEventTypeIgnoreChanged)));
  SWIG_Python_SetConstant(d, "eBreakpointEventTypeThreadChanged",SWIG_From_int(static_cast< int >(lldb::eBreakpointEventTypeThreadChanged)));
  SWIG_Python_SetConstant(d, "eBreakpointEventTypeAutoContinueChanged",SWIG_From_int(static_cast< int >(lldb::eBreakpointEventTypeAutoContinueChanged)));
  SWIG_Python_SetConstant(d, "eWatchpointEventTypeInvalidType",SWIG_From_int(static_cast< int >(lldb::eWatchpointEventTypeInvalidType)));
  SWIG_Python_SetConstant(d, "eWatchpointEventTypeAdded",SWIG_From_int(static_cast< int >(lldb::eWatchpointEventTypeAdded)));
  SWIG_Python_SetConstant(d, "eWatchpointEventTypeRemoved",SWIG_From_int(static_cast< int >(lldb::eWatchpointEventTypeRemoved)));
  SWIG_Python_SetConstant(d, "eWatchpointEventTypeEnabled",SWIG_From_int(static_cast< int >(lldb::eWatchpointEventTypeEnabled)));
  SWIG_Python_SetConstant(d, "eWatchpointEventTypeDisabled",SWIG_From_int(static_cast< int >(lldb::eWatchpointEventTypeDisabled)));
  SWIG_Python_SetConstant(d, "eWatchpointEventTypeCommandChanged",SWIG_From_int(static_cast< int >(lldb::eWatchpointEventTypeCommandChanged)));
  SWIG_Python_SetConstant(d, "eWatchpointEventTypeConditionChanged",SWIG_From_int(static_cast< int >(lldb::eWatchpointEventTypeConditionChanged)));
  SWIG_Python_SetConstant(d, "eWatchpointEventTypeIgnoreChanged",SWIG_From_int(static_cast< int >(lldb::eWatchpointEventTypeIgnoreChanged)));
  SWIG_Python_SetConstant(d, "eWatchpointEventTypeThreadChanged",SWIG_From_int(static_cast< int >(lldb::eWatchpointEventTypeThreadChanged)));
  SWIG_Python_SetConstant(d, "eWatchpointEventTypeTypeChanged",SWIG_From_int(static_cast< int >(lldb::eWatchpointEventTypeTypeChanged)));
  SWIG_Python_SetConstant(d, "eWatchpointWriteTypeDisabled",SWIG_From_int(static_cast< int >(lldb::eWatchpointWriteTypeDisabled)));
  SWIG_Python_SetConstant(d, "eWatchpointWriteTypeAlways",SWIG_From_int(static_cast< int >(lldb::eWatchpointWriteTypeAlways)));
  SWIG_Python_SetConstant(d, "eWatchpointWriteTypeOnModify",SWIG_From_int(static_cast< int >(lldb::eWatchpointWriteTypeOnModify)));
  SWIG_Python_SetConstant(d, "eLanguageTypeUnknown",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeUnknown)));
  SWIG_Python_SetConstant(d, "eLanguageTypeC89",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeC89)));
  SWIG_Python_SetConstant(d, "eLanguageTypeC",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeC)));
  SWIG_Python_SetConstant(d, "eLanguageTypeAda83",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeAda83)));
  SWIG_Python_SetConstant(d, "eLanguageTypeC_plus_plus",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeC_plus_plus)));
  SWIG_Python_SetConstant(d, "eLanguageTypeCobol74",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeCobol74)));
  SWIG_Python_SetConstant(d, "eLanguageTypeCobol85",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeCobol85)));
  SWIG_Python_SetConstant(d, "eLanguageTypeFortran77",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeFortran77)));
  SWIG_Python_SetConstant(d, "eLanguageTypeFortran90",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeFortran90)));
  SWIG_Python_SetConstant(d, "eLanguageTypePascal83",SWIG_From_int(static_cast< int >(lldb::eLanguageTypePascal83)));
  SWIG_Python_SetConstant(d, "eLanguageTypeModula2",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeModula2)));
  SWIG_Python_SetConstant(d, "eLanguageTypeJava",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeJava)));
  SWIG_Python_SetConstant(d, "eLanguageTypeC99",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeC99)));
  SWIG_Python_SetConstant(d, "eLanguageTypeAda95",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeAda95)));
  SWIG_Python_SetConstant(d, "eLanguageTypeFortran95",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeFortran95)));
  SWIG_Python_SetConstant(d, "eLanguageTypePLI",SWIG_From_int(static_cast< int >(lldb::eLanguageTypePLI)));
  SWIG_Python_SetConstant(d, "eLanguageTypeObjC",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeObjC)));
  SWIG_Python_SetConstant(d, "eLanguageTypeObjC_plus_plus",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeObjC_plus_plus)));
  SWIG_Python_SetConstant(d, "eLanguageTypeUPC",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeUPC)));
  SWIG_Python_SetConstant(d, "eLanguageTypeD",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeD)));
  SWIG_Python_SetConstant(d, "eLanguageTypePython",SWIG_From_int(static_cast< int >(lldb::eLanguageTypePython)));
  SWIG_Python_SetConstant(d, "eLanguageTypeOpenCL",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeOpenCL)));
  SWIG_Python_SetConstant(d, "eLanguageTypeGo",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeGo)));
  SWIG_Python_SetConstant(d, "eLanguageTypeModula3",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeModula3)));
  SWIG_Python_SetConstant(d, "eLanguageTypeHaskell",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeHaskell)));
  SWIG_Python_SetConstant(d, "eLanguageTypeC_plus_plus_03",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeC_plus_plus_03)));
  SWIG_Python_SetConstant(d, "eLanguageTypeC_plus_plus_11",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeC_plus_plus_11)));
  SWIG_Python_SetConstant(d, "eLanguageTypeOCaml",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeOCaml)));
  SWIG_Python_SetConstant(d, "eLanguageTypeRust",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeRust)));
  SWIG_Python_SetConstant(d, "eLanguageTypeC11",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeC11)));
  SWIG_Python_SetConstant(d, "eLanguageTypeSwift",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeSwift)));
  SWIG_Python_SetConstant(d, "eLanguageTypeJulia",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeJulia)));
  SWIG_Python_SetConstant(d, "eLanguageTypeDylan",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeDylan)));
  SWIG_Python_SetConstant(d, "eLanguageTypeC_plus_plus_14",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeC_plus_plus_14)));
  SWIG_Python_SetConstant(d, "eLanguageTypeFortran03",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeFortran03)));
  SWIG_Python_SetConstant(d, "eLanguageTypeFortran08",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeFortran08)));
  SWIG_Python_SetConstant(d, "eLanguageTypeRenderScript",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeRenderScript)));
  SWIG_Python_SetConstant(d, "eLanguageTypeBLISS",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeBLISS)));
  SWIG_Python_SetConstant(d, "eLanguageTypeKotlin",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeKotlin)));
  SWIG_Python_SetConstant(d, "eLanguageTypeZig",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeZig)));
  SWIG_Python_SetConstant(d, "eLanguageTypeCrystal",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeCrystal)));
  SWIG_Python_SetConstant(d, "eLanguageTypeC_plus_plus_17",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeC_plus_plus_17)));
  SWIG_Python_SetConstant(d, "eLanguageTypeC_plus_plus_20",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeC_plus_plus_20)));
  SWIG_Python_SetConstant(d, "eLanguageTypeC17",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeC17)));
  SWIG_Python_SetConstant(d, "eLanguageTypeFortran18",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeFortran18)));
  SWIG_Python_SetConstant(d, "eLanguageTypeAda2005",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeAda2005)));
  SWIG_Python_SetConstant(d, "eLanguageTypeAda2012",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeAda2012)));
  SWIG_Python_SetConstant(d, "eLanguageTypeHIP",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeHIP)));
  SWIG_Python_SetConstant(d, "eLanguageTypeAssembly",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeAssembly)));
  SWIG_Python_SetConstant(d, "eLanguageTypeC_sharp",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeC_sharp)));
  SWIG_Python_SetConstant(d, "eLanguageTypeMojo",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeMojo)));
  SWIG_Python_SetConstant(d, "eLanguageTypeLastStandardLanguage",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeLastStandardLanguage)));
  SWIG_Python_SetConstant(d, "eLanguageTypeMipsAssembler",SWIG_From_int(static_cast< int >(lldb::eLanguageTypeMipsAssembler)));
  SWIG_Python_SetConstant(d, "eNumLanguageTypes",SWIG_From_int(static_cast< int >(lldb::eNumLanguageTypes)));
  SWIG_Python_SetConstant(d, "eInstrumentationRuntimeTypeAddressSanitizer",SWIG_From_int(static_cast< int >(lldb::eInstrumentationRuntimeTypeAddressSanitizer)));
  SWIG_Python_SetConstant(d, "eInstrumentationRuntimeTypeThreadSanitizer",SWIG_From_int(static_cast< int >(lldb::eInstrumentationRuntimeTypeThreadSanitizer)));
  SWIG_Python_SetConstant(d, "eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer",SWIG_From_int(static_cast< int >(lldb::eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer)));
  SWIG_Python_SetConstant(d, "eInstrumentationRuntimeTypeMainThreadChecker",SWIG_From_int(static_cast< int >(lldb::eInstrumentationRuntimeTypeMainThreadChecker)));
  SWIG_Python_SetConstant(d, "eInstrumentationRuntimeTypeSwiftRuntimeReporting",SWIG_From_int(static_cast< int >(lldb::eInstrumentationRuntimeTypeSwiftRuntimeReporting)));
  SWIG_Python_SetConstant(d, "eInstrumentationRuntimeTypeLibsanitizersAsan",SWIG_From_int(static_cast< int >(lldb::eInstrumentationRuntimeTypeLibsanitizersAsan)));
  SWIG_Python_SetConstant(d, "eInstrumentationRuntimeTypeBoundsSafety",SWIG_From_int(static_cast< int >(lldb::eInstrumentationRuntimeTypeBoundsSafety)));
  SWIG_Python_SetConstant(d, "eNumInstrumentationRuntimeTypes",SWIG_From_int(static_cast< int >(lldb::eNumInstrumentationRuntimeTypes)));
  SWIG_Python_SetConstant(d, "eNoDynamicValues",SWIG_From_int(static_cast< int >(lldb::eNoDynamicValues)));
  SWIG_Python_SetConstant(d, "eDynamicCanRunTarget",SWIG_From_int(static_cast< int >(lldb::eDynamicCanRunTarget)));
  SWIG_Python_SetConstant(d, "eDynamicDontRunTarget",SWIG_From_int(static_cast< int >(lldb::eDynamicDontRunTarget)));
  SWIG_Python_SetConstant(d, "eStopShowColumnAnsiOrCaret",SWIG_From_int(static_cast< int >(lldb::eStopShowColumnAnsiOrCaret)));
  SWIG_Python_SetConstant(d, "eStopShowColumnAnsi",SWIG_From_int(static_cast< int >(lldb::eStopShowColumnAnsi)));
  SWIG_Python_SetConstant(d, "eStopShowColumnCaret",SWIG_From_int(static_cast< int >(lldb::eStopShowColumnCaret)));
  SWIG_Python_SetConstant(d, "eStopShowColumnNone",SWIG_From_int(static_cast< int >(lldb::eStopShowColumnNone)));
  SWIG_Python_SetConstant(d, "eAccessNone",SWIG_From_int(static_cast< int >(lldb::eAccessNone)));
  SWIG_Python_SetConstant(d, "eAccessPublic",SWIG_From_int(static_cast< int >(lldb::eAccessPublic)));
  SWIG_Python_SetConstant(d, "eAccessPrivate",SWIG_From_int(static_cast< int >(lldb::eAccessPrivate)));
  SWIG_Python_SetConstant(d, "eAccessProtected",SWIG_From_int(static_cast< int >(lldb::eAccessProtected)));
  SWIG_Python_SetConstant(d, "eAccessPackage",SWIG_From_int(static_cast< int >(lldb::eAccessPackage)));
  SWIG_Python_SetConstant(d, "eArgTypeAddress",SWIG_From_int(static_cast< int >(lldb::eArgTypeAddress)));
  SWIG_Python_SetConstant(d, "eArgTypeAddressOrExpression",SWIG_From_int(static_cast< int >(lldb::eArgTypeAddressOrExpression)));
  SWIG_Python_SetConstant(d, "eArgTypeAliasName",SWIG_From_int(static_cast< int >(lldb::eArgTypeAliasName)));
  SWIG_Python_SetConstant(d, "eArgTypeAliasOptions",SWIG_From_int(static_cast< int >(lldb::eArgTypeAliasOptions)));
  SWIG_Python_SetConstant(d, "eArgTypeArchitecture",SWIG_From_int(static_cast< int >(lldb::eArgTypeArchitecture)));
  SWIG_Python_SetConstant(d, "eArgTypeBoolean",SWIG_From_int(static_cast< int >(lldb::eArgTypeBoolean)));
  SWIG_Python_SetConstant(d, "eArgTypeBreakpointID",SWIG_From_int(static_cast< int >(lldb::eArgTypeBreakpointID)));
  SWIG_Python_SetConstant(d, "eArgTypeBreakpointIDRange",SWIG_From_int(static_cast< int >(lldb::eArgTypeBreakpointIDRange)));
  SWIG_Python_SetConstant(d, "eArgTypeBreakpointName",SWIG_From_int(static_cast< int >(lldb::eArgTypeBreakpointName)));
  SWIG_Python_SetConstant(d, "eArgTypeByteSize",SWIG_From_int(static_cast< int >(lldb::eArgTypeByteSize)));
  SWIG_Python_SetConstant(d, "eArgTypeClassName",SWIG_From_int(static_cast< int >(lldb::eArgTypeClassName)));
  SWIG_Python_SetConstant(d, "eArgTypeCommandName",SWIG_From_int(static_cast< int >(lldb::eArgTypeCommandName)));
  SWIG_Python_SetConstant(d, "eArgTypeCount",SWIG_From_int(static_cast< int >(lldb::eArgTypeCount)));
  SWIG_Python_SetConstant(d, "eArgTypeDescriptionVerbosity",SWIG_From_int(static_cast< int >(lldb::eArgTypeDescriptionVerbosity)));
  SWIG_Python_SetConstant(d, "eArgTypeDirectoryName",SWIG_From_int(static_cast< int >(lldb::eArgTypeDirectoryName)));
  SWIG_Python_SetConstant(d, "eArgTypeDisassemblyFlavor",SWIG_From_int(static_cast< int >(lldb::eArgTypeDisassemblyFlavor)));
  SWIG_Python_SetConstant(d, "eArgTypeEndAddress",SWIG_From_int(static_cast< int >(lldb::eArgTypeEndAddress)));
  SWIG_Python_SetConstant(d, "eArgTypeExpression",SWIG_From_int(static_cast< int >(lldb::eArgTypeExpression)));
  SWIG_Python_SetConstant(d, "eArgTypeExpressionPath",SWIG_From_int(static_cast< int >(lldb::eArgTypeExpressionPath)));
  SWIG_Python_SetConstant(d, "eArgTypeExprFormat",SWIG_From_int(static_cast< int >(lldb::eArgTypeExprFormat)));
  SWIG_Python_SetConstant(d, "eArgTypeFileLineColumn",SWIG_From_int(static_cast< int >(lldb::eArgTypeFileLineColumn)));
  SWIG_Python_SetConstant(d, "eArgTypeFilename",SWIG_From_int(static_cast< int >(lldb::eArgTypeFilename)));
  SWIG_Python_SetConstant(d, "eArgTypeFormat",SWIG_From_int(static_cast< int >(lldb::eArgTypeFormat)));
  SWIG_Python_SetConstant(d, "eArgTypeFrameIndex",SWIG_From_int(static_cast< int >(lldb::eArgTypeFrameIndex)));
  SWIG_Python_SetConstant(d, "eArgTypeFullName",SWIG_From_int(static_cast< int >(lldb::eArgTypeFullName)));
  SWIG_Python_SetConstant(d, "eArgTypeFunctionName",SWIG_From_int(static_cast< int >(lldb::eArgTypeFunctionName)));
  SWIG_Python_SetConstant(d, "eArgTypeFunctionOrSymbol",SWIG_From_int(static_cast< int >(lldb::eArgTypeFunctionOrSymbol)));
  SWIG_Python_SetConstant(d, "eArgTypeGDBFormat",SWIG_From_int(static_cast< int >(lldb::eArgTypeGDBFormat)));
  SWIG_Python_SetConstant(d, "eArgTypeHelpText",SWIG_From_int(static_cast< int >(lldb::eArgTypeHelpText)));
  SWIG_Python_SetConstant(d, "eArgTypeIndex",SWIG_From_int(static_cast< int >(lldb::eArgTypeIndex)));
  SWIG_Python_SetConstant(d, "eArgTypeLanguage",SWIG_From_int(static_cast< int >(lldb::eArgTypeLanguage)));
  SWIG_Python_SetConstant(d, "eArgTypeLineNum",SWIG_From_int(static_cast< int >(lldb::eArgTypeLineNum)));
  SWIG_Python_SetConstant(d, "eArgTypeLogCategory",SWIG_From_int(static_cast< int >(lldb::eArgTypeLogCategory)));
  SWIG_Python_SetConstant(d, "eArgTypeLogChannel",SWIG_From_int(static_cast< int >(lldb::eArgTypeLogChannel)));
  SWIG_Python_SetConstant(d, "eArgTypeMethod",SWIG_From_int(static_cast< int >(lldb::eArgTypeMethod)));
  SWIG_Python_SetConstant(d, "eArgTypeName",SWIG_From_int(static_cast< int >(lldb::eArgTypeName)));
  SWIG_Python_SetConstant(d, "eArgTypeNewPathPrefix",SWIG_From_int(static_cast< int >(lldb::eArgTypeNewPathPrefix)));
  SWIG_Python_SetConstant(d, "eArgTypeNumLines",SWIG_From_int(static_cast< int >(lldb::eArgTypeNumLines)));
  SWIG_Python_SetConstant(d, "eArgTypeNumberPerLine",SWIG_From_int(static_cast< int >(lldb::eArgTypeNumberPerLine)));
  SWIG_Python_SetConstant(d, "eArgTypeOffset",SWIG_From_int(static_cast< int >(lldb::eArgTypeOffset)));
  SWIG_Python_SetConstant(d, "eArgTypeOldPathPrefix",SWIG_From_int(static_cast< int >(lldb::eArgTypeOldPathPrefix)));
  SWIG_Python_SetConstant(d, "eArgTypeOneLiner",SWIG_From_int(static_cast< int >(lldb::eArgTypeOneLiner)));
  SWIG_Python_SetConstant(d, "eArgTypePath",SWIG_From_int(static_cast< int >(lldb::eArgTypePath)));
  SWIG_Python_SetConstant(d, "eArgTypePermissionsNumber",SWIG_From_int(static_cast< int >(lldb::eArgTypePermissionsNumber)));
  SWIG_Python_SetConstant(d, "eArgTypePermissionsString",SWIG_From_int(static_cast< int >(lldb::eArgTypePermissionsString)));
  SWIG_Python_SetConstant(d, "eArgTypePid",SWIG_From_int(static_cast< int >(lldb::eArgTypePid)));
  SWIG_Python_SetConstant(d, "eArgTypePlugin",SWIG_From_int(static_cast< int >(lldb::eArgTypePlugin)));
  SWIG_Python_SetConstant(d, "eArgTypeProcessName",SWIG_From_int(static_cast< int >(lldb::eArgTypeProcessName)));
  SWIG_Python_SetConstant(d, "eArgTypePythonClass",SWIG_From_int(static_cast< int >(lldb::eArgTypePythonClass)));
  SWIG_Python_SetConstant(d, "eArgTypePythonFunction",SWIG_From_int(static_cast< int >(lldb::eArgTypePythonFunction)));
  SWIG_Python_SetConstant(d, "eArgTypePythonScript",SWIG_From_int(static_cast< int >(lldb::eArgTypePythonScript)));
  SWIG_Python_SetConstant(d, "eArgTypeQueueName",SWIG_From_int(static_cast< int >(lldb::eArgTypeQueueName)));
  SWIG_Python_SetConstant(d, "eArgTypeRegisterName",SWIG_From_int(static_cast< int >(lldb::eArgTypeRegisterName)));
  SWIG_Python_SetConstant(d, "eArgTypeRegularExpression",SWIG_From_int(static_cast< int >(lldb::eArgTypeRegularExpression)));
  SWIG_Python_SetConstant(d, "eArgTypeRunArgs",SWIG_From_int(static_cast< int >(lldb::eArgTypeRunArgs)));
  SWIG_Python_SetConstant(d, "eArgTypeRunMode",SWIG_From_int(static_cast< int >(lldb::eArgTypeRunMode)));
  SWIG_Python_SetConstant(d, "eArgTypeScriptedCommandSynchronicity",SWIG_From_int(static_cast< int >(lldb::eArgTypeScriptedCommandSynchronicity)));
  SWIG_Python_SetConstant(d, "eArgTypeScriptLang",SWIG_From_int(static_cast< int >(lldb::eArgTypeScriptLang)));
  SWIG_Python_SetConstant(d, "eArgTypeSearchWord",SWIG_From_int(static_cast< int >(lldb::eArgTypeSearchWord)));
  SWIG_Python_SetConstant(d, "eArgTypeSelector",SWIG_From_int(static_cast< int >(lldb::eArgTypeSelector)));
  SWIG_Python_SetConstant(d, "eArgTypeSettingIndex",SWIG_From_int(static_cast< int >(lldb::eArgTypeSettingIndex)));
  SWIG_Python_SetConstant(d, "eArgTypeSettingKey",SWIG_From_int(static_cast< int >(lldb::eArgTypeSettingKey)));
  SWIG_Python_SetConstant(d, "eArgTypeSettingPrefix",SWIG_From_int(static_cast< int >(lldb::eArgTypeSettingPrefix)));
  SWIG_Python_SetConstant(d, "eArgTypeSettingVariableName",SWIG_From_int(static_cast< int >(lldb::eArgTypeSettingVariableName)));
  SWIG_Python_SetConstant(d, "eArgTypeShlibName",SWIG_From_int(static_cast< int >(lldb::eArgTypeShlibName)));
  SWIG_Python_SetConstant(d, "eArgTypeSourceFile",SWIG_From_int(static_cast< int >(lldb::eArgTypeSourceFile)));
  SWIG_Python_SetConstant(d, "eArgTypeSortOrder",SWIG_From_int(static_cast< int >(lldb::eArgTypeSortOrder)));
  SWIG_Python_SetConstant(d, "eArgTypeStartAddress",SWIG_From_int(static_cast< int >(lldb::eArgTypeStartAddress)));
  SWIG_Python_SetConstant(d, "eArgTypeSummaryString",SWIG_From_int(static_cast< int >(lldb::eArgTypeSummaryString)));
  SWIG_Python_SetConstant(d, "eArgTypeSymbol",SWIG_From_int(static_cast< int >(lldb::eArgTypeSymbol)));
  SWIG_Python_SetConstant(d, "eArgTypeThreadID",SWIG_From_int(static_cast< int >(lldb::eArgTypeThreadID)));
  SWIG_Python_SetConstant(d, "eArgTypeThreadIndex",SWIG_From_int(static_cast< int >(lldb::eArgTypeThreadIndex)));
  SWIG_Python_SetConstant(d, "eArgTypeThreadName",SWIG_From_int(static_cast< int >(lldb::eArgTypeThreadName)));
  SWIG_Python_SetConstant(d, "eArgTypeTypeName",SWIG_From_int(static_cast< int >(lldb::eArgTypeTypeName)));
  SWIG_Python_SetConstant(d, "eArgTypeUnsignedInteger",SWIG_From_int(static_cast< int >(lldb::eArgTypeUnsignedInteger)));
  SWIG_Python_SetConstant(d, "eArgTypeUnixSignal",SWIG_From_int(static_cast< int >(lldb::eArgTypeUnixSignal)));
  SWIG_Python_SetConstant(d, "eArgTypeVarName",SWIG_From_int(static_cast< int >(lldb::eArgTypeVarName)));
  SWIG_Python_SetConstant(d, "eArgTypeValue",SWIG_From_int(static_cast< int >(lldb::eArgTypeValue)));
  SWIG_Python_SetConstant(d, "eArgTypeWidth",SWIG_From_int(static_cast< int >(lldb::eArgTypeWidth)));
  SWIG_Python_SetConstant(d, "eArgTypeNone",SWIG_From_int(static_cast< int >(lldb::eArgTypeNone)));
  SWIG_Python_SetConstant(d, "eArgTypePlatform",SWIG_From_int(static_cast< int >(lldb::eArgTypePlatform)));
  SWIG_Python_SetConstant(d, "eArgTypeWatchpointID",SWIG_From_int(static_cast< int >(lldb::eArgTypeWatchpointID)));
  SWIG_Python_SetConstant(d, "eArgTypeWatchpointIDRange",SWIG_From_int(static_cast< int >(lldb::eArgTypeWatchpointIDRange)));
  SWIG_Python_SetConstant(d, "eArgTypeWatchType",SWIG_From_int(static_cast< int >(lldb::eArgTypeWatchType)));
  SWIG_Python_SetConstant(d, "eArgRawInput",SWIG_From_int(static_cast< int >(lldb::eArgRawInput)));
  SWIG_Python_SetConstant(d, "eArgTypeCommand",SWIG_From_int(static_cast< int >(lldb::eArgTypeCommand)));
  SWIG_Python_SetConstant(d, "eArgTypeColumnNum",SWIG_From_int(static_cast< int >(lldb::eArgTypeColumnNum)));
  SWIG_Python_SetConstant(d, "eArgTypeModuleUUID",SWIG_From_int(static_cast< int >(lldb::eArgTypeModuleUUID)));
  SWIG_Python_SetConstant(d, "eArgTypeSaveCoreStyle",SWIG_From_int(static_cast< int >(lldb::eArgTypeSaveCoreStyle)));
  SWIG_Python_SetConstant(d, "eArgTypeLogHandler",SWIG_From_int(static_cast< int >(lldb::eArgTypeLogHandler)));
  SWIG_Python_SetConstant(d, "eArgTypeSEDStylePair",SWIG_From_int(static_cast< int >(lldb::eArgTypeSEDStylePair)));
  SWIG_Python_SetConstant(d, "eArgTypeRecognizerID",SWIG_From_int(static_cast< int >(lldb::eArgTypeRecognizerID)));
  SWIG_Python_SetConstant(d, "eArgTypeConnectURL",SWIG_From_int(static_cast< int >(lldb::eArgTypeConnectURL)));
  SWIG_Python_SetConstant(d, "eArgTypeTargetID",SWIG_From_int(static_cast< int >(lldb::eArgTypeTargetID)));
  SWIG_Python_SetConstant(d, "eArgTypeStopHookID",SWIG_From_int(static_cast< int >(lldb::eArgTypeStopHookID)));
  SWIG_Python_SetConstant(d, "eArgTypeCompletionType",SWIG_From_int(static_cast< int >(lldb::eArgTypeCompletionType)));
  SWIG_Python_SetConstant(d, "eArgTypeRemotePath",SWIG_From_int(static_cast< int >(lldb::eArgTypeRemotePath)));
  SWIG_Python_SetConstant(d, "eArgTypeRemoteFilename",SWIG_From_int(static_cast< int >(lldb::eArgTypeRemoteFilename)));
  SWIG_Python_SetConstant(d, "eArgTypeModule",SWIG_From_int(static_cast< int >(lldb::eArgTypeModule)));
  SWIG_Python_SetConstant(d, "eArgTypeCPUName",SWIG_From_int(static_cast< int >(lldb::eArgTypeCPUName)));
  SWIG_Python_SetConstant(d, "eArgTypeCPUFeatures",SWIG_From_int(static_cast< int >(lldb::eArgTypeCPUFeatures)));
  SWIG_Python_SetConstant(d, "eArgTypeManagedPlugin",SWIG_From_int(static_cast< int >(lldb::eArgTypeManagedPlugin)));
  SWIG_Python_SetConstant(d, "eArgTypeProtocol",SWIG_From_int(static_cast< int >(lldb::eArgTypeProtocol)));
  SWIG_Python_SetConstant(d, "eArgTypeExceptionStage",SWIG_From_int(static_cast< int >(lldb::eArgTypeExceptionStage)));
  SWIG_Python_SetConstant(d, "eArgTypeNameMatchStyle",SWIG_From_int(static_cast< int >(lldb::eArgTypeNameMatchStyle)));
  SWIG_Python_SetConstant(d, "eArgTypeLastArg",SWIG_From_int(static_cast< int >(lldb::eArgTypeLastArg)));
  SWIG_Python_SetConstant(d, "eSymbolTypeAny",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeAny)));
  SWIG_Python_SetConstant(d, "eSymbolTypeInvalid",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeInvalid)));
  SWIG_Python_SetConstant(d, "eSymbolTypeAbsolute",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeAbsolute)));
  SWIG_Python_SetConstant(d, "eSymbolTypeCode",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeCode)));
  SWIG_Python_SetConstant(d, "eSymbolTypeResolver",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeResolver)));
  SWIG_Python_SetConstant(d, "eSymbolTypeData",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeData)));
  SWIG_Python_SetConstant(d, "eSymbolTypeTrampoline",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeTrampoline)));
  SWIG_Python_SetConstant(d, "eSymbolTypeRuntime",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeRuntime)));
  SWIG_Python_SetConstant(d, "eSymbolTypeException",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeException)));
  SWIG_Python_SetConstant(d, "eSymbolTypeSourceFile",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeSourceFile)));
  SWIG_Python_SetConstant(d, "eSymbolTypeHeaderFile",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeHeaderFile)));
  SWIG_Python_SetConstant(d, "eSymbolTypeObjectFile",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeObjectFile)));
  SWIG_Python_SetConstant(d, "eSymbolTypeCommonBlock",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeCommonBlock)));
  SWIG_Python_SetConstant(d, "eSymbolTypeBlock",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeBlock)));
  SWIG_Python_SetConstant(d, "eSymbolTypeLocal",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeLocal)));
  SWIG_Python_SetConstant(d, "eSymbolTypeParam",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeParam)));
  SWIG_Python_SetConstant(d, "eSymbolTypeVariable",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeVariable)));
  SWIG_Python_SetConstant(d, "eSymbolTypeVariableType",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeVariableType)));
  SWIG_Python_SetConstant(d, "eSymbolTypeLineEntry",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeLineEntry)));
  SWIG_Python_SetConstant(d, "eSymbolTypeLineHeader",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeLineHeader)));
  SWIG_Python_SetConstant(d, "eSymbolTypeScopeBegin",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeScopeBegin)));
  SWIG_Python_SetConstant(d, "eSymbolTypeScopeEnd",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeScopeEnd)));
  SWIG_Python_SetConstant(d, "eSymbolTypeAdditional",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeAdditional)));
  SWIG_Python_SetConstant(d, "eSymbolTypeCompiler",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeCompiler)));
  SWIG_Python_SetConstant(d, "eSymbolTypeInstrumentation",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeInstrumentation)));
  SWIG_Python_SetConstant(d, "eSymbolTypeUndefined",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeUndefined)));
  SWIG_Python_SetConstant(d, "eSymbolTypeObjCClass",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeObjCClass)));
  SWIG_Python_SetConstant(d, "eSymbolTypeObjCMetaClass",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeObjCMetaClass)));
  SWIG_Python_SetConstant(d, "eSymbolTypeObjCIVar",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeObjCIVar)));
  SWIG_Python_SetConstant(d, "eSymbolTypeReExported",SWIG_From_int(static_cast< int >(lldb::eSymbolTypeReExported)));
  SWIG_Python_SetConstant(d, "eSectionTypeInvalid",SWIG_From_int(static_cast< int >(lldb::eSectionTypeInvalid)));
  SWIG_Python_SetConstant(d, "eSectionTypeCode",SWIG_From_int(static_cast< int >(lldb::eSectionTypeCode)));
  SWIG_Python_SetConstant(d, "eSectionTypeContainer",SWIG_From_int(static_cast< int >(lldb::eSectionTypeContainer)));
  SWIG_Python_SetConstant(d, "eSectionTypeData",SWIG_From_int(static_cast< int >(lldb::eSectionTypeData)));
  SWIG_Python_SetConstant(d, "eSectionTypeDataCString",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDataCString)));
  SWIG_Python_SetConstant(d, "eSectionTypeDataCStringPointers",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDataCStringPointers)));
  SWIG_Python_SetConstant(d, "eSectionTypeDataSymbolAddress",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDataSymbolAddress)));
  SWIG_Python_SetConstant(d, "eSectionTypeData4",SWIG_From_int(static_cast< int >(lldb::eSectionTypeData4)));
  SWIG_Python_SetConstant(d, "eSectionTypeData8",SWIG_From_int(static_cast< int >(lldb::eSectionTypeData8)));
  SWIG_Python_SetConstant(d, "eSectionTypeData16",SWIG_From_int(static_cast< int >(lldb::eSectionTypeData16)));
  SWIG_Python_SetConstant(d, "eSectionTypeDataPointers",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDataPointers)));
  SWIG_Python_SetConstant(d, "eSectionTypeDebug",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDebug)));
  SWIG_Python_SetConstant(d, "eSectionTypeZeroFill",SWIG_From_int(static_cast< int >(lldb::eSectionTypeZeroFill)));
  SWIG_Python_SetConstant(d, "eSectionTypeDataObjCMessageRefs",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDataObjCMessageRefs)));
  SWIG_Python_SetConstant(d, "eSectionTypeDataObjCCFStrings",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDataObjCCFStrings)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugAbbrev",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugAbbrev)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugAddr",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugAddr)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugAranges",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugAranges)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugCuIndex",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugCuIndex)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugFrame",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugFrame)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugInfo",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugInfo)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugLine",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugLine)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugLoc",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugLoc)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugMacInfo",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugMacInfo)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugMacro",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugMacro)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugPubNames",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugPubNames)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugPubTypes",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugPubTypes)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugRanges",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugRanges)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugStr",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugStr)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugStrOffsets",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugStrOffsets)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFAppleNames",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFAppleNames)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFAppleTypes",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFAppleTypes)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFAppleNamespaces",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFAppleNamespaces)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFAppleObjC",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFAppleObjC)));
  SWIG_Python_SetConstant(d, "eSectionTypeELFSymbolTable",SWIG_From_int(static_cast< int >(lldb::eSectionTypeELFSymbolTable)));
  SWIG_Python_SetConstant(d, "eSectionTypeELFDynamicSymbols",SWIG_From_int(static_cast< int >(lldb::eSectionTypeELFDynamicSymbols)));
  SWIG_Python_SetConstant(d, "eSectionTypeELFRelocationEntries",SWIG_From_int(static_cast< int >(lldb::eSectionTypeELFRelocationEntries)));
  SWIG_Python_SetConstant(d, "eSectionTypeELFDynamicLinkInfo",SWIG_From_int(static_cast< int >(lldb::eSectionTypeELFDynamicLinkInfo)));
  SWIG_Python_SetConstant(d, "eSectionTypeEHFrame",SWIG_From_int(static_cast< int >(lldb::eSectionTypeEHFrame)));
  SWIG_Python_SetConstant(d, "eSectionTypeARMexidx",SWIG_From_int(static_cast< int >(lldb::eSectionTypeARMexidx)));
  SWIG_Python_SetConstant(d, "eSectionTypeARMextab",SWIG_From_int(static_cast< int >(lldb::eSectionTypeARMextab)));
  SWIG_Python_SetConstant(d, "eSectionTypeCompactUnwind",SWIG_From_int(static_cast< int >(lldb::eSectionTypeCompactUnwind)));
  SWIG_Python_SetConstant(d, "eSectionTypeGoSymtab",SWIG_From_int(static_cast< int >(lldb::eSectionTypeGoSymtab)));
  SWIG_Python_SetConstant(d, "eSectionTypeAbsoluteAddress",SWIG_From_int(static_cast< int >(lldb::eSectionTypeAbsoluteAddress)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFGNUDebugAltLink",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFGNUDebugAltLink)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugTypes",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugTypes)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugNames",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugNames)));
  SWIG_Python_SetConstant(d, "eSectionTypeOther",SWIG_From_int(static_cast< int >(lldb::eSectionTypeOther)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugLineStr",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugLineStr)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugRngLists",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugRngLists)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugLocLists",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugLocLists)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugAbbrevDwo",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugAbbrevDwo)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugInfoDwo",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugInfoDwo)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugStrDwo",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugStrDwo)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugStrOffsetsDwo",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugStrOffsetsDwo)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugTypesDwo",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugTypesDwo)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugRngListsDwo",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugRngListsDwo)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugLocDwo",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugLocDwo)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugLocListsDwo",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugLocListsDwo)));
  SWIG_Python_SetConstant(d, "eSectionTypeDWARFDebugTuIndex",SWIG_From_int(static_cast< int >(lldb::eSectionTypeDWARFDebugTuIndex)));
  SWIG_Python_SetConstant(d, "eSectionTypeCTF",SWIG_From_int(static_cast< int >(lldb::eSectionTypeCTF)));
  SWIG_Python_SetConstant(d, "eSectionTypeLLDBTypeSummaries",SWIG_From_int(static_cast< int >(lldb::eSectionTypeLLDBTypeSummaries)));
  SWIG_Python_SetConstant(d, "eSectionTypeLLDBFormatters",SWIG_From_int(static_cast< int >(lldb::eSectionTypeLLDBFormatters)));
  SWIG_Python_SetConstant(d, "eSectionTypeSwiftModules",SWIG_From_int(static_cast< int >(lldb::eSectionTypeSwiftModules)));
  SWIG_Python_SetConstant(d, "eSectionTypeWasmName",SWIG_From_int(static_cast< int >(lldb::eSectionTypeWasmName)));
  SWIG_Python_SetConstant(d, "eEmulateInstructionOptionNone",SWIG_From_int(static_cast< int >(lldb::eEmulateInstructionOptionNone)));
  SWIG_Python_SetConstant(d, "eEmulateInstructionOptionAutoAdvancePC",SWIG_From_int(static_cast< int >(lldb::eEmulateInstructionOptionAutoAdvancePC)));
  SWIG_Python_SetConstant(d, "eEmulateInstructionOptionIgnoreConditions",SWIG_From_int(static_cast< int >(lldb::eEmulateInstructionOptionIgnoreConditions)));
  SWIG_Python_SetConstant(d, "eFunctionNameTypeNone",SWIG_From_int(static_cast< int >(lldb::eFunctionNameTypeNone)));
  SWIG_Python_SetConstant(d, "eFunctionNameTypeAuto",SWIG_From_int(static_cast< int >(lldb::eFunctionNameTypeAuto)));
  SWIG_Python_SetConstant(d, "eFunctionNameTypeFull",SWIG_From_int(static_cast< int >(lldb::eFunctionNameTypeFull)));
  SWIG_Python_SetConstant(d, "eFunctionNameTypeBase",SWIG_From_int(static_cast< int >(lldb::eFunctionNameTypeBase)));
  SWIG_Python_SetConstant(d, "eFunctionNameTypeMethod",SWIG_From_int(static_cast< int >(lldb::eFunctionNameTypeMethod)));
  SWIG_Python_SetConstant(d, "eFunctionNameTypeSelector",SWIG_From_int(static_cast< int >(lldb::eFunctionNameTypeSelector)));
  SWIG_Python_SetConstant(d, "eFunctionNameTypeAny",SWIG_From_int(static_cast< int >(lldb::eFunctionNameTypeAny)));
  SWIG_Python_SetConstant(d, "eBasicTypeInvalid",SWIG_From_int(static_cast< int >(lldb::eBasicTypeInvalid)));
  SWIG_Python_SetConstant(d, "eBasicTypeVoid",SWIG_From_int(static_cast< int >(lldb::eBasicTypeVoid)));
  SWIG_Python_SetConstant(d, "eBasicTypeChar",SWIG_From_int(static_cast< int >(lldb::eBasicTypeChar)));
  SWIG_Python_SetConstant(d, "eBasicTypeSignedChar",SWIG_From_int(static_cast< int >(lldb::eBasicTypeSignedChar)));
  SWIG_Python_SetConstant(d, "eBasicTypeUnsignedChar",SWIG_From_int(static_cast< int >(lldb::eBasicTypeUnsignedChar)));
  SWIG_Python_SetConstant(d, "eBasicTypeWChar",SWIG_From_int(static_cast< int >(lldb::eBasicTypeWChar)));
  SWIG_Python_SetConstant(d, "eBasicTypeSignedWChar",SWIG_From_int(static_cast< int >(lldb::eBasicTypeSignedWChar)));
  SWIG_Python_SetConstant(d, "eBasicTypeUnsignedWChar",SWIG_From_int(static_cast< int >(lldb::eBasicTypeUnsignedWChar)));
  SWIG_Python_SetConstant(d, "eBasicTypeChar16",SWIG_From_int(static_cast< int >(lldb::eBasicTypeChar16)));
  SWIG_Python_SetConstant(d, "eBasicTypeChar32",SWIG_From_int(static_cast< int >(lldb::eBasicTypeChar32)));
  SWIG_Python_SetConstant(d, "eBasicTypeChar8",SWIG_From_int(static_cast< int >(lldb::eBasicTypeChar8)));
  SWIG_Python_SetConstant(d, "eBasicTypeShort",SWIG_From_int(static_cast< int >(lldb::eBasicTypeShort)));
  SWIG_Python_SetConstant(d, "eBasicTypeUnsignedShort",SWIG_From_int(static_cast< int >(lldb::eBasicTypeUnsignedShort)));
  SWIG_Python_SetConstant(d, "eBasicTypeInt",SWIG_From_int(static_cast< int >(lldb::eBasicTypeInt)));
  SWIG_Python_SetConstant(d, "eBasicTypeUnsignedInt",SWIG_From_int(static_cast< int >(lldb::eBasicTypeUnsignedInt)));
  SWIG_Python_SetConstant(d, "eBasicTypeLong",SWIG_From_int(static_cast< int >(lldb::eBasicTypeLong)));
  SWIG_Python_SetConstant(d, "eBasicTypeUnsignedLong",SWIG_From_int(static_cast< int >(lldb::eBasicTypeUnsignedLong)));
  SWIG_Python_SetConstant(d, "eBasicTypeLongLong",SWIG_From_int(static_cast< int >(lldb::eBasicTypeLongLong)));
  SWIG_Python_SetConstant(d, "eBasicTypeUnsignedLongLong",SWIG_From_int(static_cast< int >(lldb::eBasicTypeUnsignedLongLong)));
  SWIG_Python_SetConstant(d, "eBasicTypeInt128",SWIG_From_int(static_cast< int >(lldb::eBasicTypeInt128)));
  SWIG_Python_SetConstant(d, "eBasicTypeUnsignedInt128",SWIG_From_int(static_cast< int >(lldb::eBasicTypeUnsignedInt128)));
  SWIG_Python_SetConstant(d, "eBasicTypeBool",SWIG_From_int(static_cast< int >(lldb::eBasicTypeBool)));
  SWIG_Python_SetConstant(d, "eBasicTypeHalf",SWIG_From_int(static_cast< int >(lldb::eBasicTypeHalf)));
  SWIG_Python_SetConstant(d, "eBasicTypeFloat",SWIG_From_int(static_cast< int >(lldb::eBasicTypeFloat)));
  SWIG_Python_SetConstant(d, "eBasicTypeDouble",SWIG_From_int(static_cast< int >(lldb::eBasicTypeDouble)));
  SWIG_Python_SetConstant(d, "eBasicTypeLongDouble",SWIG_From_int(static_cast< int >(lldb::eBasicTypeLongDouble)));
  SWIG_Python_SetConstant(d, "eBasicTypeFloatComplex",SWIG_From_int(static_cast< int >(lldb::eBasicTypeFloatComplex)));
  SWIG_Python_SetConstant(d, "eBasicTypeDoubleComplex",SWIG_From_int(static_cast< int >(lldb::eBasicTypeDoubleComplex)));
  SWIG_Python_SetConstant(d, "eBasicTypeLongDoubleComplex",SWIG_From_int(static_cast< int >(lldb::eBasicTypeLongDoubleComplex)));
  SWIG_Python_SetConstant(d, "eBasicTypeObjCID",SWIG_From_int(static_cast< int >(lldb::eBasicTypeObjCID)));
  SWIG_Python_SetConstant(d, "eBasicTypeObjCClass",SWIG_From_int(static_cast< int >(lldb::eBasicTypeObjCClass)));
  SWIG_Python_SetConstant(d, "eBasicTypeObjCSel",SWIG_From_int(static_cast< int >(lldb::eBasicTypeObjCSel)));
  SWIG_Python_SetConstant(d, "eBasicTypeNullPtr",SWIG_From_int(static_cast< int >(lldb::eBasicTypeNullPtr)));
  SWIG_Python_SetConstant(d, "eBasicTypeOther",SWIG_From_int(static_cast< int >(lldb::eBasicTypeOther)));
  SWIG_Python_SetConstant(d, "eBasicTypeFloat128",SWIG_From_int(static_cast< int >(lldb::eBasicTypeFloat128)));
  SWIG_Python_SetConstant(d, "eTraceTypeNone",SWIG_From_int(static_cast< int >(lldb::eTraceTypeNone)));
  SWIG_Python_SetConstant(d, "eTraceTypeProcessorTrace",SWIG_From_int(static_cast< int >(lldb::eTraceTypeProcessorTrace)));
  SWIG_Python_SetConstant(d, "eStructuredDataTypeInvalid",SWIG_From_int(static_cast< int >(lldb::eStructuredDataTypeInvalid)));
  SWIG_Python_SetConstant(d, "eStructuredDataTypeNull",SWIG_From_int(static_cast< int >(lldb::eStructuredDataTypeNull)));
  SWIG_Python_SetConstant(d, "eStructuredDataTypeGeneric",SWIG_From_int(static_cast< int >(lldb::eStructuredDataTypeGeneric)));
  SWIG_Python_SetConstant(d, "eStructuredDataTypeArray",SWIG_From_int(static_cast< int >(lldb::eStructuredDataTypeArray)));
  SWIG_Python_SetConstant(d, "eStructuredDataTypeInteger",SWIG_From_int(static_cast< int >(lldb::eStructuredDataTypeInteger)));
  SWIG_Python_SetConstant(d, "eStructuredDataTypeFloat",SWIG_From_int(static_cast< int >(lldb::eStructuredDataTypeFloat)));
  SWIG_Python_SetConstant(d, "eStructuredDataTypeBoolean",SWIG_From_int(static_cast< int >(lldb::eStructuredDataTypeBoolean)));
  SWIG_Python_SetConstant(d, "eStructuredDataTypeString",SWIG_From_int(static_cast< int >(lldb::eStructuredDataTypeString)));
  SWIG_Python_SetConstant(d, "eStructuredDataTypeDictionary",SWIG_From_int(static_cast< int >(lldb::eStructuredDataTypeDictionary)));
  SWIG_Python_SetConstant(d, "eStructuredDataTypeSignedInteger",SWIG_From_int(static_cast< int >(lldb::eStructuredDataTypeSignedInteger)));
  SWIG_Python_SetConstant(d, "eStructuredDataTypeUnsignedInteger",SWIG_From_int(static_cast< int >(lldb::eStructuredDataTypeUnsignedInteger)));
  SWIG_Python_SetConstant(d, "eTypeClassInvalid",SWIG_From_int(static_cast< int >(lldb::eTypeClassInvalid)));
  SWIG_Python_SetConstant(d, "eTypeClassArray",SWIG_From_int(static_cast< int >(lldb::eTypeClassArray)));
  SWIG_Python_SetConstant(d, "eTypeClassBlockPointer",SWIG_From_int(static_cast< int >(lldb::eTypeClassBlockPointer)));
  SWIG_Python_SetConstant(d, "eTypeClassBuiltin",SWIG_From_int(static_cast< int >(lldb::eTypeClassBuiltin)));
  SWIG_Python_SetConstant(d, "eTypeClassClass",SWIG_From_int(static_cast< int >(lldb::eTypeClassClass)));
  SWIG_Python_SetConstant(d, "eTypeClassComplexFloat",SWIG_From_int(static_cast< int >(lldb::eTypeClassComplexFloat)));
  SWIG_Python_SetConstant(d, "eTypeClassComplexInteger",SWIG_From_int(static_cast< int >(lldb::eTypeClassComplexInteger)));
  SWIG_Python_SetConstant(d, "eTypeClassEnumeration",SWIG_From_int(static_cast< int >(lldb::eTypeClassEnumeration)));
  SWIG_Python_SetConstant(d, "eTypeClassFunction",SWIG_From_int(static_cast< int >(lldb::eTypeClassFunction)));
  SWIG_Python_SetConstant(d, "eTypeClassMemberPointer",SWIG_From_int(static_cast< int >(lldb::eTypeClassMemberPointer)));
  SWIG_Python_SetConstant(d, "eTypeClassObjCObject",SWIG_From_int(static_cast< int >(lldb::eTypeClassObjCObject)));
  SWIG_Python_SetConstant(d, "eTypeClassObjCInterface",SWIG_From_int(static_cast< int >(lldb::eTypeClassObjCInterface)));
  SWIG_Python_SetConstant(d, "eTypeClassObjCObjectPointer",SWIG_From_int(static_cast< int >(lldb::eTypeClassObjCObjectPointer)));
  SWIG_Python_SetConstant(d, "eTypeClassPointer",SWIG_From_int(static_cast< int >(lldb::eTypeClassPointer)));
  SWIG_Python_SetConstant(d, "eTypeClassReference",SWIG_From_int(static_cast< int >(lldb::eTypeClassReference)));
  SWIG_Python_SetConstant(d, "eTypeClassStruct",SWIG_From_int(static_cast< int >(lldb::eTypeClassStruct)));
  SWIG_Python_SetConstant(d, "eTypeClassTypedef",SWIG_From_int(static_cast< int >(lldb::eTypeClassTypedef)));
  SWIG_Python_SetConstant(d, "eTypeClassUnion",SWIG_From_int(static_cast< int >(lldb::eTypeClassUnion)));
  SWIG_Python_SetConstant(d, "eTypeClassVector",SWIG_From_int(static_cast< int >(lldb::eTypeClassVector)));
  SWIG_Python_SetConstant(d, "eTypeClassOther",SWIG_From_int(static_cast< int >(lldb::eTypeClassOther)));
  SWIG_Python_SetConstant(d, "eTypeClassAny",SWIG_From_int(static_cast< int >(lldb::eTypeClassAny)));
  SWIG_Python_SetConstant(d, "eTemplateArgumentKindNull",SWIG_From_int(static_cast< int >(lldb::eTemplateArgumentKindNull)));
  SWIG_Python_SetConstant(d, "eTemplateArgumentKindType",SWIG_From_int(static_cast< int >(lldb::eTemplateArgumentKindType)));
  SWIG_Python_SetConstant(d, "eTemplateArgumentKindDeclaration",SWIG_From_int(static_cast< int >(lldb::eTemplateArgumentKindDeclaration)));
  SWIG_Python_SetConstant(d, "eTemplateArgumentKindIntegral",SWIG_From_int(static_cast< int >(lldb::eTemplateArgumentKindIntegral)));
  SWIG_Python_SetConstant(d, "eTemplateArgumentKindTemplate",SWIG_From_int(static_cast< int >(lldb::eTemplateArgumentKindTemplate)));
  SWIG_Python_SetConstant(d, "eTemplateArgumentKindTemplateExpansion",SWIG_From_int(static_cast< int >(lldb::eTemplateArgumentKindTemplateExpansion)));
  SWIG_Python_SetConstant(d, "eTemplateArgumentKindExpression",SWIG_From_int(static_cast< int >(lldb::eTemplateArgumentKindExpression)));
  SWIG_Python_SetConstant(d, "eTemplateArgumentKindPack",SWIG_From_int(static_cast< int >(lldb::eTemplateArgumentKindPack)));
  SWIG_Python_SetConstant(d, "eTemplateArgumentKindNullPtr",SWIG_From_int(static_cast< int >(lldb::eTemplateArgumentKindNullPtr)));
  SWIG_Python_SetConstant(d, "eTemplateArgumentKindStructuralValue",SWIG_From_int(static_cast< int >(lldb::eTemplateArgumentKindStructuralValue)));
  SWIG_Python_SetConstant(d, "eFormatterMatchExact",SWIG_From_int(static_cast< int >(lldb::eFormatterMatchExact)));
  SWIG_Python_SetConstant(d, "eFormatterMatchRegex",SWIG_From_int(static_cast< int >(lldb::eFormatterMatchRegex)));
  SWIG_Python_SetConstant(d, "eFormatterMatchCallback",SWIG_From_int(static_cast< int >(lldb::eFormatterMatchCallback)));
  SWIG_Python_SetConstant(d, "eLastFormatterMatchType",SWIG_From_int(static_cast< int >(lldb::eLastFormatterMatchType)));
  SWIG_Python_SetConstant(d, "eTypeOptionNone",SWIG_From_int(static_cast< int >(lldb::eTypeOptionNone)));
  SWIG_Python_SetConstant(d, "eTypeOptionCascade",SWIG_From_int(static_cast< int >(lldb::eTypeOptionCascade)));
  SWIG_Python_SetConstant(d, "eTypeOptionSkipPointers",SWIG_From_int(static_cast< int >(lldb::eTypeOptionSkipPointers)));
  SWIG_Python_SetConstant(d, "eTypeOptionSkipReferences",SWIG_From_int(static_cast< int >(lldb::eTypeOptionSkipReferences)));
  SWIG_Python_SetConstant(d, "eTypeOptionHideChildren",SWIG_From_int(static_cast< int >(lldb::eTypeOptionHideChildren)));
  SWIG_Python_SetConstant(d, "eTypeOptionHideValue",SWIG_From_int(static_cast< int >(lldb::eTypeOptionHideValue)));
  SWIG_Python_SetConstant(d, "eTypeOptionShowOneLiner",SWIG_From_int(static_cast< int >(lldb::eTypeOptionShowOneLiner)));
  SWIG_Python_SetConstant(d, "eTypeOptionHideNames",SWIG_From_int(static_cast< int >(lldb::eTypeOptionHideNames)));
  SWIG_Python_SetConstant(d, "eTypeOptionNonCacheable",SWIG_From_int(static_cast< int >(lldb::eTypeOptionNonCacheable)));
  SWIG_Python_SetConstant(d, "eTypeOptionHideEmptyAggregates",SWIG_From_int(static_cast< int >(lldb::eTypeOptionHideEmptyAggregates)));
  SWIG_Python_SetConstant(d, "eTypeOptionFrontEndWantsDereference",SWIG_From_int(static_cast< int >(lldb::eTypeOptionFrontEndWantsDereference)));
  SWIG_Python_SetConstant(d, "eFrameCompareInvalid",SWIG_From_int(static_cast< int >(lldb::eFrameCompareInvalid)));
  SWIG_Python_SetConstant(d, "eFrameCompareUnknown",SWIG_From_int(static_cast< int >(lldb::eFrameCompareUnknown)));
  SWIG_Python_SetConstant(d, "eFrameCompareEqual",SWIG_From_int(static_cast< int >(lldb::eFrameCompareEqual)));
  SWIG_Python_SetConstant(d, "eFrameCompareSameParent",SWIG_From_int(static_cast< int >(lldb::eFrameCompareSameParent)));
  SWIG_Python_SetConstant(d, "eFrameCompareYounger",SWIG_From_int(static_cast< int >(lldb::eFrameCompareYounger)));
  SWIG_Python_SetConstant(d, "eFrameCompareOlder",SWIG_From_int(static_cast< int >(lldb::eFrameCompareOlder)));
  SWIG_Python_SetConstant(d, "eFilePermissionsUserRead",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsUserRead)));
  SWIG_Python_SetConstant(d, "eFilePermissionsUserWrite",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsUserWrite)));
  SWIG_Python_SetConstant(d, "eFilePermissionsUserExecute",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsUserExecute)));
  SWIG_Python_SetConstant(d, "eFilePermissionsGroupRead",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsGroupRead)));
  SWIG_Python_SetConstant(d, "eFilePermissionsGroupWrite",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsGroupWrite)));
  SWIG_Python_SetConstant(d, "eFilePermissionsGroupExecute",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsGroupExecute)));
  SWIG_Python_SetConstant(d, "eFilePermissionsWorldRead",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsWorldRead)));
  SWIG_Python_SetConstant(d, "eFilePermissionsWorldWrite",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsWorldWrite)));
  SWIG_Python_SetConstant(d, "eFilePermissionsWorldExecute",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsWorldExecute)));
  SWIG_Python_SetConstant(d, "eFilePermissionsUserRW",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsUserRW)));
  SWIG_Python_SetConstant(d, "eFileFilePermissionsUserRX",SWIG_From_int(static_cast< int >(lldb::eFileFilePermissionsUserRX)));
  SWIG_Python_SetConstant(d, "eFilePermissionsUserRWX",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsUserRWX)));
  SWIG_Python_SetConstant(d, "eFilePermissionsGroupRW",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsGroupRW)));
  SWIG_Python_SetConstant(d, "eFilePermissionsGroupRX",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsGroupRX)));
  SWIG_Python_SetConstant(d, "eFilePermissionsGroupRWX",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsGroupRWX)));
  SWIG_Python_SetConstant(d, "eFilePermissionsWorldRW",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsWorldRW)));
  SWIG_Python_SetConstant(d, "eFilePermissionsWorldRX",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsWorldRX)));
  SWIG_Python_SetConstant(d, "eFilePermissionsWorldRWX",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsWorldRWX)));
  SWIG_Python_SetConstant(d, "eFilePermissionsEveryoneR",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsEveryoneR)));
  SWIG_Python_SetConstant(d, "eFilePermissionsEveryoneW",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsEveryoneW)));
  SWIG_Python_SetConstant(d, "eFilePermissionsEveryoneX",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsEveryoneX)));
  SWIG_Python_SetConstant(d, "eFilePermissionsEveryoneRW",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsEveryoneRW)));
  SWIG_Python_SetConstant(d, "eFilePermissionsEveryoneRX",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsEveryoneRX)));
  SWIG_Python_SetConstant(d, "eFilePermissionsEveryoneRWX",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsEveryoneRWX)));
  SWIG_Python_SetConstant(d, "eFilePermissionsFileDefault",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsFileDefault)));
  SWIG_Python_SetConstant(d, "eFilePermissionsDirectoryDefault",SWIG_From_int(static_cast< int >(lldb::eFilePermissionsDirectoryDefault)));
  SWIG_Python_SetConstant(d, "eQueueItemKindUnknown",SWIG_From_int(static_cast< int >(lldb::eQueueItemKindUnknown)));
  SWIG_Python_SetConstant(d, "eQueueItemKindFunction",SWIG_From_int(static_cast< int >(lldb::eQueueItemKindFunction)));
  SWIG_Python_SetConstant(d, "eQueueItemKindBlock",SWIG_From_int(static_cast< int >(lldb::eQueueItemKindBlock)));
  SWIG_Python_SetConstant(d, "eQueueKindUnknown",SWIG_From_int(static_cast< int >(lldb::eQueueKindUnknown)));
  SWIG_Python_SetConstant(d, "eQueueKindSerial",SWIG_From_int(static_cast< int >(lldb::eQueueKindSerial)));
  SWIG_Python_SetConstant(d, "eQueueKindConcurrent",SWIG_From_int(static_cast< int >(lldb::eQueueKindConcurrent)));
  SWIG_Python_SetConstant(d, "eExpressionEvaluationParse",SWIG_From_int(static_cast< int >(lldb::eExpressionEvaluationParse)));
  SWIG_Python_SetConstant(d, "eExpressionEvaluationIRGen",SWIG_From_int(static_cast< int >(lldb::eExpressionEvaluationIRGen)));
  SWIG_Python_SetConstant(d, "eExpressionEvaluationExecution",SWIG_From_int(static_cast< int >(lldb::eExpressionEvaluationExecution)));
  SWIG_Python_SetConstant(d, "eExpressionEvaluationComplete",SWIG_From_int(static_cast< int >(lldb::eExpressionEvaluationComplete)));
  SWIG_Python_SetConstant(d, "eInstructionControlFlowKindUnknown",SWIG_From_int(static_cast< int >(lldb::eInstructionControlFlowKindUnknown)));
  SWIG_Python_SetConstant(d, "eInstructionControlFlowKindOther",SWIG_From_int(static_cast< int >(lldb::eInstructionControlFlowKindOther)));
  SWIG_Python_SetConstant(d, "eInstructionControlFlowKindCall",SWIG_From_int(static_cast< int >(lldb::eInstructionControlFlowKindCall)));
  SWIG_Python_SetConstant(d, "eInstructionControlFlowKindReturn",SWIG_From_int(static_cast< int >(lldb::eInstructionControlFlowKindReturn)));
  SWIG_Python_SetConstant(d, "eInstructionControlFlowKindJump",SWIG_From_int(static_cast< int >(lldb::eInstructionControlFlowKindJump)));
  SWIG_Python_SetConstant(d, "eInstructionControlFlowKindCondJump",SWIG_From_int(static_cast< int >(lldb::eInstructionControlFlowKindCondJump)));
  SWIG_Python_SetConstant(d, "eInstructionControlFlowKindFarCall",SWIG_From_int(static_cast< int >(lldb::eInstructionControlFlowKindFarCall)));
  SWIG_Python_SetConstant(d, "eInstructionControlFlowKindFarReturn",SWIG_From_int(static_cast< int >(lldb::eInstructionControlFlowKindFarReturn)));
  SWIG_Python_SetConstant(d, "eInstructionControlFlowKindFarJump",SWIG_From_int(static_cast< int >(lldb::eInstructionControlFlowKindFarJump)));
  SWIG_Python_SetConstant(d, "eWatchpointKindWrite",SWIG_From_int(static_cast< int >(lldb::eWatchpointKindWrite)));
  SWIG_Python_SetConstant(d, "eWatchpointKindRead",SWIG_From_int(static_cast< int >(lldb::eWatchpointKindRead)));
  SWIG_Python_SetConstant(d, "eGdbSignalBadAccess",SWIG_From_int(static_cast< int >(lldb::eGdbSignalBadAccess)));
  SWIG_Python_SetConstant(d, "eGdbSignalBadInstruction",SWIG_From_int(static_cast< int >(lldb::eGdbSignalBadInstruction)));
  SWIG_Python_SetConstant(d, "eGdbSignalArithmetic",SWIG_From_int(static_cast< int >(lldb::eGdbSignalArithmetic)));
  SWIG_Python_SetConstant(d, "eGdbSignalEmulation",SWIG_From_int(static_cast< int >(lldb::eGdbSignalEmulation)));
  SWIG_Python_SetConstant(d, "eGdbSignalSoftware",SWIG_From_int(static_cast< int >(lldb::eGdbSignalSoftware)));
  SWIG_Python_SetConstant(d, "eGdbSignalBreakpoint",SWIG_From_int(static_cast< int >(lldb::eGdbSignalBreakpoint)));
  SWIG_Python_SetConstant(d, "ePathTypeLLDBShlibDir",SWIG_From_int(static_cast< int >(lldb::ePathTypeLLDBShlibDir)));
  SWIG_Python_SetConstant(d, "ePathTypeSupportExecutableDir",SWIG_From_int(static_cast< int >(lldb::ePathTypeSupportExecutableDir)));
  SWIG_Python_SetConstant(d, "ePathTypeHeaderDir",SWIG_From_int(static_cast< int >(lldb::ePathTypeHeaderDir)));
  SWIG_Python_SetConstant(d, "ePathTypePythonDir",SWIG_From_int(static_cast< int >(lldb::ePathTypePythonDir)));
  SWIG_Python_SetConstant(d, "ePathTypeLLDBSystemPlugins",SWIG_From_int(static_cast< int >(lldb::ePathTypeLLDBSystemPlugins)));
  SWIG_Python_SetConstant(d, "ePathTypeLLDBUserPlugins",SWIG_From_int(static_cast< int >(lldb::ePathTypeLLDBUserPlugins)));
  SWIG_Python_SetConstant(d, "ePathTypeLLDBTempSystemDir",SWIG_From_int(static_cast< int >(lldb::ePathTypeLLDBTempSystemDir)));
  SWIG_Python_SetConstant(d, "ePathTypeGlobalLLDBTempSystemDir",SWIG_From_int(static_cast< int >(lldb::ePathTypeGlobalLLDBTempSystemDir)));
  SWIG_Python_SetConstant(d, "ePathTypeClangDir",SWIG_From_int(static_cast< int >(lldb::ePathTypeClangDir)));
  SWIG_Python_SetConstant(d, "eMemberFunctionKindUnknown",SWIG_From_int(static_cast< int >(lldb::eMemberFunctionKindUnknown)));
  SWIG_Python_SetConstant(d, "eMemberFunctionKindConstructor",SWIG_From_int(static_cast< int >(lldb::eMemberFunctionKindConstructor)));
  SWIG_Python_SetConstant(d, "eMemberFunctionKindDestructor",SWIG_From_int(static_cast< int >(lldb::eMemberFunctionKindDestructor)));
  SWIG_Python_SetConstant(d, "eMemberFunctionKindInstanceMethod",SWIG_From_int(static_cast< int >(lldb::eMemberFunctionKindInstanceMethod)));
  SWIG_Python_SetConstant(d, "eMemberFunctionKindStaticMethod",SWIG_From_int(static_cast< int >(lldb::eMemberFunctionKindStaticMethod)));
  SWIG_Python_SetConstant(d, "eMatchTypeNormal",SWIG_From_int(static_cast< int >(lldb::eMatchTypeNormal)));
  SWIG_Python_SetConstant(d, "eMatchTypeRegex",SWIG_From_int(static_cast< int >(lldb::eMatchTypeRegex)));
  SWIG_Python_SetConstant(d, "eMatchTypeStartsWith",SWIG_From_int(static_cast< int >(lldb::eMatchTypeStartsWith)));
  SWIG_Python_SetConstant(d, "eMatchTypeRegexInsensitive",SWIG_From_int(static_cast< int >(lldb::eMatchTypeRegexInsensitive)));
  SWIG_Python_SetConstant(d, "eTypeHasChildren",SWIG_From_int(static_cast< int >(lldb::eTypeHasChildren)));
  SWIG_Python_SetConstant(d, "eTypeHasValue",SWIG_From_int(static_cast< int >(lldb::eTypeHasValue)));
  SWIG_Python_SetConstant(d, "eTypeIsArray",SWIG_From_int(static_cast< int >(lldb::eTypeIsArray)));
  SWIG_Python_SetConstant(d, "eTypeIsBlock",SWIG_From_int(static_cast< int >(lldb::eTypeIsBlock)));
  SWIG_Python_SetConstant(d, "eTypeIsBuiltIn",SWIG_From_int(static_cast< int >(lldb::eTypeIsBuiltIn)));
  SWIG_Python_SetConstant(d, "eTypeIsClass",SWIG_From_int(static_cast< int >(lldb::eTypeIsClass)));
  SWIG_Python_SetConstant(d, "eTypeIsCPlusPlus",SWIG_From_int(static_cast< int >(lldb::eTypeIsCPlusPlus)));
  SWIG_Python_SetConstant(d, "eTypeIsEnumeration",SWIG_From_int(static_cast< int >(lldb::eTypeIsEnumeration)));
  SWIG_Python_SetConstant(d, "eTypeIsFuncPrototype",SWIG_From_int(static_cast< int >(lldb::eTypeIsFuncPrototype)));
  SWIG_Python_SetConstant(d, "eTypeIsMember",SWIG_From_int(static_cast< int >(lldb::eTypeIsMember)));
  SWIG_Python_SetConstant(d, "eTypeIsObjC",SWIG_From_int(static_cast< int >(lldb::eTypeIsObjC)));
  SWIG_Python_SetConstant(d, "eTypeIsPointer",SWIG_From_int(static_cast< int >(lldb::eTypeIsPointer)));
  SWIG_Python_SetConstant(d, "eTypeIsReference",SWIG_From_int(static_cast< int >(lldb::eTypeIsReference)));
  SWIG_Python_SetConstant(d, "eTypeIsStructUnion",SWIG_From_int(static_cast< int >(lldb::eTypeIsStructUnion)));
  SWIG_Python_SetConstant(d, "eTypeIsTemplate",SWIG_From_int(static_cast< int >(lldb::eTypeIsTemplate)));
  SWIG_Python_SetConstant(d, "eTypeIsTypedef",SWIG_From_int(static_cast< int >(lldb::eTypeIsTypedef)));
  SWIG_Python_SetConstant(d, "eTypeIsVector",SWIG_From_int(static_cast< int >(lldb::eTypeIsVector)));
  SWIG_Python_SetConstant(d, "eTypeIsScalar",SWIG_From_int(static_cast< int >(lldb::eTypeIsScalar)));
  SWIG_Python_SetConstant(d, "eTypeIsInteger",SWIG_From_int(static_cast< int >(lldb::eTypeIsInteger)));
  SWIG_Python_SetConstant(d, "eTypeIsFloat",SWIG_From_int(static_cast< int >(lldb::eTypeIsFloat)));
  SWIG_Python_SetConstant(d, "eTypeIsComplex",SWIG_From_int(static_cast< int >(lldb::eTypeIsComplex)));
  SWIG_Python_SetConstant(d, "eTypeIsSigned",SWIG_From_int(static_cast< int >(lldb::eTypeIsSigned)));
  SWIG_Python_SetConstant(d, "eTypeInstanceIsPointer",SWIG_From_int(static_cast< int >(lldb::eTypeInstanceIsPointer)));
  SWIG_Python_SetConstant(d, "eCommandRequiresTarget",SWIG_From_int(static_cast< int >(lldb::eCommandRequiresTarget)));
  SWIG_Python_SetConstant(d, "eCommandRequiresProcess",SWIG_From_int(static_cast< int >(lldb::eCommandRequiresProcess)));
  SWIG_Python_SetConstant(d, "eCommandRequiresThread",SWIG_From_int(static_cast< int >(lldb::eCommandRequiresThread)));
  SWIG_Python_SetConstant(d, "eCommandRequiresFrame",SWIG_From_int(static_cast< int >(lldb::eCommandRequiresFrame)));
  SWIG_Python_SetConstant(d, "eCommandRequiresRegContext",SWIG_From_int(static_cast< int >(lldb::eCommandRequiresRegContext)));
  SWIG_Python_SetConstant(d, "eCommandTryTargetAPILock",SWIG_From_int(static_cast< int >(lldb::eCommandTryTargetAPILock)));
  SWIG_Python_SetConstant(d, "eCommandProcessMustBeLaunched",SWIG_From_int(static_cast< int >(lldb::eCommandProcessMustBeLaunched)));
  SWIG_Python_SetConstant(d, "eCommandProcessMustBePaused",SWIG_From_int(static_cast< int >(lldb::eCommandProcessMustBePaused)));
  SWIG_Python_SetConstant(d, "eCommandProcessMustBeTraced",SWIG_From_int(static_cast< int >(lldb::eCommandProcessMustBeTraced)));
  SWIG_Python_SetConstant(d, "eTypeSummaryCapped",SWIG_From_bool(static_cast< bool >(lldb::eTypeSummaryCapped)));
  SWIG_Python_SetConstant(d, "eTypeSummaryUncapped",SWIG_From_bool(static_cast< bool >(lldb::eTypeSummaryUncapped)));
  SWIG_Python_SetConstant(d, "eCommandInterpreterResultSuccess",SWIG_From_int(static_cast< int >(lldb::eCommandInterpreterResultSuccess)));
  SWIG_Python_SetConstant(d, "eCommandInterpreterResultInferiorCrash",SWIG_From_int(static_cast< int >(lldb::eCommandInterpreterResultInferiorCrash)));
  SWIG_Python_SetConstant(d, "eCommandInterpreterResultCommandError",SWIG_From_int(static_cast< int >(lldb::eCommandInterpreterResultCommandError)));
  SWIG_Python_SetConstant(d, "eCommandInterpreterResultQuitRequested",SWIG_From_int(static_cast< int >(lldb::eCommandInterpreterResultQuitRequested)));
  SWIG_Python_SetConstant(d, "eSaveCoreUnspecified",SWIG_From_int(static_cast< int >(lldb::eSaveCoreUnspecified)));
  SWIG_Python_SetConstant(d, "eSaveCoreFull",SWIG_From_int(static_cast< int >(lldb::eSaveCoreFull)));
  SWIG_Python_SetConstant(d, "eSaveCoreDirtyOnly",SWIG_From_int(static_cast< int >(lldb::eSaveCoreDirtyOnly)));
  SWIG_Python_SetConstant(d, "eSaveCoreStackOnly",SWIG_From_int(static_cast< int >(lldb::eSaveCoreStackOnly)));
  SWIG_Python_SetConstant(d, "eSaveCoreCustomOnly",SWIG_From_int(static_cast< int >(lldb::eSaveCoreCustomOnly)));
  SWIG_Python_SetConstant(d, "eTraceEventDisabledSW",SWIG_From_int(static_cast< int >(lldb::eTraceEventDisabledSW)));
  SWIG_Python_SetConstant(d, "eTraceEventDisabledHW",SWIG_From_int(static_cast< int >(lldb::eTraceEventDisabledHW)));
  SWIG_Python_SetConstant(d, "eTraceEventCPUChanged",SWIG_From_int(static_cast< int >(lldb::eTraceEventCPUChanged)));
  SWIG_Python_SetConstant(d, "eTraceEventHWClockTick",SWIG_From_int(static_cast< int >(lldb::eTraceEventHWClockTick)));
  SWIG_Python_SetConstant(d, "eTraceEventSyncPoint",SWIG_From_int(static_cast< int >(lldb::eTraceEventSyncPoint)));
  SWIG_Python_SetConstant(d, "eTraceItemKindError",SWIG_From_int(static_cast< int >(lldb::eTraceItemKindError)));
  SWIG_Python_SetConstant(d, "eTraceItemKindEvent",SWIG_From_int(static_cast< int >(lldb::eTraceItemKindEvent)));
  SWIG_Python_SetConstant(d, "eTraceItemKindInstruction",SWIG_From_int(static_cast< int >(lldb::eTraceItemKindInstruction)));
  SWIG_Python_SetConstant(d, "eTraceCursorSeekTypeBeginning",SWIG_From_int(static_cast< int >(lldb::eTraceCursorSeekTypeBeginning)));
  SWIG_Python_SetConstant(d, "eTraceCursorSeekTypeCurrent",SWIG_From_int(static_cast< int >(lldb::eTraceCursorSeekTypeCurrent)));
  SWIG_Python_SetConstant(d, "eTraceCursorSeekTypeEnd",SWIG_From_int(static_cast< int >(lldb::eTraceCursorSeekTypeEnd)));
  SWIG_Python_SetConstant(d, "eDWIMPrintVerbosityNone",SWIG_From_int(static_cast< int >(lldb::eDWIMPrintVerbosityNone)));
  SWIG_Python_SetConstant(d, "eDWIMPrintVerbosityExpression",SWIG_From_int(static_cast< int >(lldb::eDWIMPrintVerbosityExpression)));
  SWIG_Python_SetConstant(d, "eDWIMPrintVerbosityFull",SWIG_From_int(static_cast< int >(lldb::eDWIMPrintVerbosityFull)));
  SWIG_Python_SetConstant(d, "eWatchPointValueKindInvalid",SWIG_From_int(static_cast< int >(lldb::eWatchPointValueKindInvalid)));
  SWIG_Python_SetConstant(d, "eWatchPointValueKindVariable",SWIG_From_int(static_cast< int >(lldb::eWatchPointValueKindVariable)));
  SWIG_Python_SetConstant(d, "eWatchPointValueKindExpression",SWIG_From_int(static_cast< int >(lldb::eWatchPointValueKindExpression)));
  SWIG_Python_SetConstant(d, "eNoCompletion",SWIG_From_int(static_cast< int >(lldb::eNoCompletion)));
  SWIG_Python_SetConstant(d, "eSourceFileCompletion",SWIG_From_int(static_cast< int >(lldb::eSourceFileCompletion)));
  SWIG_Python_SetConstant(d, "eDiskFileCompletion",SWIG_From_int(static_cast< int >(lldb::eDiskFileCompletion)));
  SWIG_Python_SetConstant(d, "eDiskDirectoryCompletion",SWIG_From_int(static_cast< int >(lldb::eDiskDirectoryCompletion)));
  SWIG_Python_SetConstant(d, "eSymbolCompletion",SWIG_From_int(static_cast< int >(lldb::eSymbolCompletion)));
  SWIG_Python_SetConstant(d, "eModuleCompletion",SWIG_From_int(static_cast< int >(lldb::eModuleCompletion)));
  SWIG_Python_SetConstant(d, "eSettingsNameCompletion",SWIG_From_int(static_cast< int >(lldb::eSettingsNameCompletion)));
  SWIG_Python_SetConstant(d, "ePlatformPluginCompletion",SWIG_From_int(static_cast< int >(lldb::ePlatformPluginCompletion)));
  SWIG_Python_SetConstant(d, "eArchitectureCompletion",SWIG_From_int(static_cast< int >(lldb::eArchitectureCompletion)));
  SWIG_Python_SetConstant(d, "eVariablePathCompletion",SWIG_From_int(static_cast< int >(lldb::eVariablePathCompletion)));
  SWIG_Python_SetConstant(d, "eRegisterCompletion",SWIG_From_int(static_cast< int >(lldb::eRegisterCompletion)));
  SWIG_Python_SetConstant(d, "eBreakpointCompletion",SWIG_From_int(static_cast< int >(lldb::eBreakpointCompletion)));
  SWIG_Python_SetConstant(d, "eProcessPluginCompletion",SWIG_From_int(static_cast< int >(lldb::eProcessPluginCompletion)));
  SWIG_Python_SetConstant(d, "eDisassemblyFlavorCompletion",SWIG_From_int(static_cast< int >(lldb::eDisassemblyFlavorCompletion)));
  SWIG_Python_SetConstant(d, "eTypeLanguageCompletion",SWIG_From_int(static_cast< int >(lldb::eTypeLanguageCompletion)));
  SWIG_Python_SetConstant(d, "eFrameIndexCompletion",SWIG_From_int(static_cast< int >(lldb::eFrameIndexCompletion)));
  SWIG_Python_SetConstant(d, "eModuleUUIDCompletion",SWIG_From_int(static_cast< int >(lldb::eModuleUUIDCompletion)));
  SWIG_Python_SetConstant(d, "eStopHookIDCompletion",SWIG_From_int(static_cast< int >(lldb::eStopHookIDCompletion)));
  SWIG_Python_SetConstant(d, "eThreadIndexCompletion",SWIG_From_int(static_cast< int >(lldb::eThreadIndexCompletion)));
  SWIG_Python_SetConstant(d, "eWatchpointIDCompletion",SWIG_From_int(static_cast< int >(lldb::eWatchpointIDCompletion)));
  SWIG_Python_SetConstant(d, "eBreakpointNameCompletion",SWIG_From_int(static_cast< int >(lldb::eBreakpointNameCompletion)));
  SWIG_Python_SetConstant(d, "eProcessIDCompletion",SWIG_From_int(static_cast< int >(lldb::eProcessIDCompletion)));
  SWIG_Python_SetConstant(d, "eProcessNameCompletion",SWIG_From_int(static_cast< int >(lldb::eProcessNameCompletion)));
  SWIG_Python_SetConstant(d, "eRemoteDiskFileCompletion",SWIG_From_int(static_cast< int >(lldb::eRemoteDiskFileCompletion)));
  SWIG_Python_SetConstant(d, "eRemoteDiskDirectoryCompletion",SWIG_From_int(static_cast< int >(lldb::eRemoteDiskDirectoryCompletion)));
  SWIG_Python_SetConstant(d, "eTypeCategoryNameCompletion",SWIG_From_int(static_cast< int >(lldb::eTypeCategoryNameCompletion)));
  SWIG_Python_SetConstant(d, "eCustomCompletion",SWIG_From_int(static_cast< int >(lldb::eCustomCompletion)));
  SWIG_Python_SetConstant(d, "eThreadIDCompletion",SWIG_From_int(static_cast< int >(lldb::eThreadIDCompletion)));
  SWIG_Python_SetConstant(d, "eManagedPluginCompletion",SWIG_From_int(static_cast< int >(lldb::eManagedPluginCompletion)));
  SWIG_Python_SetConstant(d, "eTerminatorCompletion",SWIG_From_int(static_cast< int >(lldb::eTerminatorCompletion)));
  SWIG_Python_SetConstant(d, "eRefetch",SWIG_From_int(static_cast< int >(lldb::eRefetch)));
  SWIG_Python_SetConstant(d, "eReuse",SWIG_From_int(static_cast< int >(lldb::eReuse)));
  SWIG_Python_SetConstant(d, "eSymbolDownloadOff",SWIG_From_int(static_cast< int >(lldb::eSymbolDownloadOff)));
  SWIG_Python_SetConstant(d, "eSymbolDownloadBackground",SWIG_From_int(static_cast< int >(lldb::eSymbolDownloadBackground)));
  SWIG_Python_SetConstant(d, "eSymbolDownloadForeground",SWIG_From_int(static_cast< int >(lldb::eSymbolDownloadForeground)));
  SWIG_Python_SetConstant(d, "eAddressMaskTypeCode",SWIG_From_int(static_cast< int >(lldb::eAddressMaskTypeCode)));
  SWIG_Python_SetConstant(d, "eAddressMaskTypeData",SWIG_From_int(static_cast< int >(lldb::eAddressMaskTypeData)));
  SWIG_Python_SetConstant(d, "eAddressMaskTypeAny",SWIG_From_int(static_cast< int >(lldb::eAddressMaskTypeAny)));
  SWIG_Python_SetConstant(d, "eAddressMaskTypeAll",SWIG_From_int(static_cast< int >(lldb::eAddressMaskTypeAll)));
  SWIG_Python_SetConstant(d, "eAddressMaskRangeLow",SWIG_From_int(static_cast< int >(lldb::eAddressMaskRangeLow)));
  SWIG_Python_SetConstant(d, "eAddressMaskRangeHigh",SWIG_From_int(static_cast< int >(lldb::eAddressMaskRangeHigh)));
  SWIG_Python_SetConstant(d, "eAddressMaskRangeAny",SWIG_From_int(static_cast< int >(lldb::eAddressMaskRangeAny)));
  SWIG_Python_SetConstant(d, "eAddressMaskRangeAll",SWIG_From_int(static_cast< int >(lldb::eAddressMaskRangeAll)));
  SWIG_Python_SetConstant(d, "eBroadcastBitProgress",SWIG_From_int(static_cast< int >(lldb::eBroadcastBitProgress)));
  SWIG_Python_SetConstant(d, "eBroadcastBitWarning",SWIG_From_int(static_cast< int >(lldb::eBroadcastBitWarning)));
  SWIG_Python_SetConstant(d, "eBroadcastBitError",SWIG_From_int(static_cast< int >(lldb::eBroadcastBitError)));
  SWIG_Python_SetConstant(d, "eBroadcastSymbolChange",SWIG_From_int(static_cast< int >(lldb::eBroadcastSymbolChange)));
  SWIG_Python_SetConstant(d, "eBroadcastBitProgressCategory",SWIG_From_int(static_cast< int >(lldb::eBroadcastBitProgressCategory)));
  SWIG_Python_SetConstant(d, "eBroadcastBitExternalProgress",SWIG_From_int(static_cast< int >(lldb::eBroadcastBitExternalProgress)));
  SWIG_Python_SetConstant(d, "eBroadcastBitExternalProgressCategory",SWIG_From_int(static_cast< int >(lldb::eBroadcastBitExternalProgressCategory)));
  SWIG_Python_SetConstant(d, "eSeverityError",SWIG_From_int(static_cast< int >(lldb::eSeverityError)));
  SWIG_Python_SetConstant(d, "eSeverityWarning",SWIG_From_int(static_cast< int >(lldb::eSeverityWarning)));
  SWIG_Python_SetConstant(d, "eSeverityInfo",SWIG_From_int(static_cast< int >(lldb::eSeverityInfo)));
  SWIG_Python_SetConstant(d, "eCommandReturnObjectPrintCallbackSkipped",SWIG_From_int(static_cast< int >(lldb::eCommandReturnObjectPrintCallbackSkipped)));
  SWIG_Python_SetConstant(d, "eCommandReturnObjectPrintCallbackHandled",SWIG_From_int(static_cast< int >(lldb::eCommandReturnObjectPrintCallbackHandled)));
  SWIG_Python_SetConstant(d, "eStopDisassemblyTypeNever",SWIG_From_int(static_cast< int >(lldb::eStopDisassemblyTypeNever)));
  SWIG_Python_SetConstant(d, "eStopDisassemblyTypeNoDebugInfo",SWIG_From_int(static_cast< int >(lldb::eStopDisassemblyTypeNoDebugInfo)));
  SWIG_Python_SetConstant(d, "eStopDisassemblyTypeNoSource",SWIG_From_int(static_cast< int >(lldb::eStopDisassemblyTypeNoSource)));
  SWIG_Python_SetConstant(d, "eStopDisassemblyTypeAlways",SWIG_From_int(static_cast< int >(lldb::eStopDisassemblyTypeAlways)));
  SWIG_Python_SetConstant(d, "eExceptionStageCreate",SWIG_From_int(static_cast< int >(lldb::eExceptionStageCreate)));
  SWIG_Python_SetConstant(d, "eExceptionStageThrow",SWIG_From_int(static_cast< int >(lldb::eExceptionStageThrow)));
  SWIG_Python_SetConstant(d, "eExceptionStageReThrow",SWIG_From_int(static_cast< int >(lldb::eExceptionStageReThrow)));
  SWIG_Python_SetConstant(d, "eExceptionStageCatch",SWIG_From_int(static_cast< int >(lldb::eExceptionStageCatch)));
  SWIG_Python_SetConstant(d, "eNameMatchStyleAuto",SWIG_From_int(static_cast< int >(lldb::eNameMatchStyleAuto)));
  SWIG_Python_SetConstant(d, "eNameMatchStyleFull",SWIG_From_int(static_cast< int >(lldb::eNameMatchStyleFull)));
  SWIG_Python_SetConstant(d, "eNameMatchStyleBase",SWIG_From_int(static_cast< int >(lldb::eNameMatchStyleBase)));
  SWIG_Python_SetConstant(d, "eNameMatchStyleMethod",SWIG_From_int(static_cast< int >(lldb::eNameMatchStyleMethod)));
  SWIG_Python_SetConstant(d, "eNameMatchStyleSelector",SWIG_From_int(static_cast< int >(lldb::eNameMatchStyleSelector)));
  SWIG_Python_SetConstant(d, "eNameMatchStyleRegex",SWIG_From_int(static_cast< int >(lldb::eNameMatchStyleRegex)));
  SWIG_Python_SetConstant(d, "SBCommandInterpreter_eBroadcastBitThreadShouldExit",SWIG_From_int(static_cast< int >(lldb::SBCommandInterpreter::eBroadcastBitThreadShouldExit)));
  SWIG_Python_SetConstant(d, "SBCommandInterpreter_eBroadcastBitResetPrompt",SWIG_From_int(static_cast< int >(lldb::SBCommandInterpreter::eBroadcastBitResetPrompt)));
  SWIG_Python_SetConstant(d, "SBCommandInterpreter_eBroadcastBitQuitCommandReceived",SWIG_From_int(static_cast< int >(lldb::SBCommandInterpreter::eBroadcastBitQuitCommandReceived)));
  SWIG_Python_SetConstant(d, "SBCommandInterpreter_eBroadcastBitAsynchronousOutputData",SWIG_From_int(static_cast< int >(lldb::SBCommandInterpreter::eBroadcastBitAsynchronousOutputData)));
  SWIG_Python_SetConstant(d, "SBCommandInterpreter_eBroadcastBitAsynchronousErrorData",SWIG_From_int(static_cast< int >(lldb::SBCommandInterpreter::eBroadcastBitAsynchronousErrorData)));
  SWIG_Python_SetConstant(d, "SBCommunication_eBroadcastBitDisconnected",SWIG_From_int(static_cast< int >(lldb::SBCommunication::eBroadcastBitDisconnected)));
  SWIG_Python_SetConstant(d, "SBCommunication_eBroadcastBitReadThreadGotBytes",SWIG_From_int(static_cast< int >(lldb::SBCommunication::eBroadcastBitReadThreadGotBytes)));
  SWIG_Python_SetConstant(d, "SBCommunication_eBroadcastBitReadThreadDidExit",SWIG_From_int(static_cast< int >(lldb::SBCommunication::eBroadcastBitReadThreadDidExit)));
  SWIG_Python_SetConstant(d, "SBCommunication_eBroadcastBitReadThreadShouldExit",SWIG_From_int(static_cast< int >(lldb::SBCommunication::eBroadcastBitReadThreadShouldExit)));
  SWIG_Python_SetConstant(d, "SBCommunication_eBroadcastBitPacketAvailable",SWIG_From_int(static_cast< int >(lldb::SBCommunication::eBroadcastBitPacketAvailable)));
  SWIG_Python_SetConstant(d, "SBCommunication_eAllEventBits",SWIG_From_int(static_cast< int >(lldb::SBCommunication::eAllEventBits)));
  SWIG_Python_SetConstant(d, "SBDebugger_eBroadcastBitProgress",SWIG_From_int(static_cast< int >(lldb::SBDebugger::eBroadcastBitProgress)));
  SWIG_Python_SetConstant(d, "SBDebugger_eBroadcastBitWarning",SWIG_From_int(static_cast< int >(lldb::SBDebugger::eBroadcastBitWarning)));
  SWIG_Python_SetConstant(d, "SBDebugger_eBroadcastBitError",SWIG_From_int(static_cast< int >(lldb::SBDebugger::eBroadcastBitError)));
  SWIG_Python_SetConstant(d, "SBDebugger_eBroadcastBitProgressCategory",SWIG_From_int(static_cast< int >(lldb::SBDebugger::eBroadcastBitProgressCategory)));
  SWIG_Python_SetConstant(d, "SBDebugger_eBroadcastBitExternalProgress",SWIG_From_int(static_cast< int >(lldb::SBDebugger::eBroadcastBitExternalProgress)));
  SWIG_Python_SetConstant(d, "SBDebugger_eBroadcastBitExternalProgressCategory",SWIG_From_int(static_cast< int >(lldb::SBDebugger::eBroadcastBitExternalProgressCategory)));
  SWIG_Python_SetConstant(d, "eLanguageNameAda",SWIG_From_int(static_cast< int >(lldb::eLanguageNameAda)));
  SWIG_Python_SetConstant(d, "eLanguageNameBLISS",SWIG_From_int(static_cast< int >(lldb::eLanguageNameBLISS)));
  SWIG_Python_SetConstant(d, "eLanguageNameC",SWIG_From_int(static_cast< int >(lldb::eLanguageNameC)));
  SWIG_Python_SetConstant(d, "eLanguageNameC_plus_plus",SWIG_From_int(static_cast< int >(lldb::eLanguageNameC_plus_plus)));
  SWIG_Python_SetConstant(d, "eLanguageNameCobol",SWIG_From_int(static_cast< int >(lldb::eLanguageNameCobol)));
  SWIG_Python_SetConstant(d, "eLanguageNameCrystal",SWIG_From_int(static_cast< int >(lldb::eLanguageNameCrystal)));
  SWIG_Python_SetConstant(d, "eLanguageNameD",SWIG_From_int(static_cast< int >(lldb::eLanguageNameD)));
  SWIG_Python_SetConstant(d, "eLanguageNameDylan",SWIG_From_int(static_cast< int >(lldb::eLanguageNameDylan)));
  SWIG_Python_SetConstant(d, "eLanguageNameFortran",SWIG_From_int(static_cast< int >(lldb::eLanguageNameFortran)));
  SWIG_Python_SetConstant(d, "eLanguageNameGo",SWIG_From_int(static_cast< int >(lldb::eLanguageNameGo)));
  SWIG_Python_SetConstant(d, "eLanguageNameHaskell",SWIG_From_int(static_cast< int >(lldb::eLanguageNameHaskell)));
  SWIG_Python_SetConstant(d, "eLanguageNameJava",SWIG_From_int(static_cast< int >(lldb::eLanguageNameJava)));
  SWIG_Python_SetConstant(d, "eLanguageNameJulia",SWIG_From_int(static_cast< int >(lldb::eLanguageNameJulia)));
  SWIG_Python_SetConstant(d, "eLanguageNameKotlin",SWIG_From_int(static_cast< int >(lldb::eLanguageNameKotlin)));
  SWIG_Python_SetConstant(d, "eLanguageNameModula2",SWIG_From_int(static_cast< int >(lldb::eLanguageNameModula2)));
  SWIG_Python_SetConstant(d, "eLanguageNameModula3",SWIG_From_int(static_cast< int >(lldb::eLanguageNameModula3)));
  SWIG_Python_SetConstant(d, "eLanguageNameObjC",SWIG_From_int(static_cast< int >(lldb::eLanguageNameObjC)));
  SWIG_Python_SetConstant(d, "eLanguageNameObjC_plus_plus",SWIG_From_int(static_cast< int >(lldb::eLanguageNameObjC_plus_plus)));
  SWIG_Python_SetConstant(d, "eLanguageNameOCaml",SWIG_From_int(static_cast< int >(lldb::eLanguageNameOCaml)));
  SWIG_Python_SetConstant(d, "eLanguageNameOpenCL_C",SWIG_From_int(static_cast< int >(lldb::eLanguageNameOpenCL_C)));
  SWIG_Python_SetConstant(d, "eLanguageNamePascal",SWIG_From_int(static_cast< int >(lldb::eLanguageNamePascal)));
  SWIG_Python_SetConstant(d, "eLanguageNamePLI",SWIG_From_int(static_cast< int >(lldb::eLanguageNamePLI)));
  SWIG_Python_SetConstant(d, "eLanguageNamePython",SWIG_From_int(static_cast< int >(lldb::eLanguageNamePython)));
  SWIG_Python_SetConstant(d, "eLanguageNameRenderScript",SWIG_From_int(static_cast< int >(lldb::eLanguageNameRenderScript)));
  SWIG_Python_SetConstant(d, "eLanguageNameRust",SWIG_From_int(static_cast< int >(lldb::eLanguageNameRust)));
  SWIG_Python_SetConstant(d, "eLanguageNameSwift",SWIG_From_int(static_cast< int >(lldb::eLanguageNameSwift)));
  SWIG_Python_SetConstant(d, "eLanguageNameUPC",SWIG_From_int(static_cast< int >(lldb::eLanguageNameUPC)));
  SWIG_Python_SetConstant(d, "eLanguageNameZig",SWIG_From_int(static_cast< int >(lldb::eLanguageNameZig)));
  SWIG_Python_SetConstant(d, "eLanguageNameAssembly",SWIG_From_int(static_cast< int >(lldb::eLanguageNameAssembly)));
  SWIG_Python_SetConstant(d, "eLanguageNameC_sharp",SWIG_From_int(static_cast< int >(lldb::eLanguageNameC_sharp)));
  SWIG_Python_SetConstant(d, "eLanguageNameMojo",SWIG_From_int(static_cast< int >(lldb::eLanguageNameMojo)));
  SWIG_Python_SetConstant(d, "eLanguageNameGLSL",SWIG_From_int(static_cast< int >(lldb::eLanguageNameGLSL)));
  SWIG_Python_SetConstant(d, "eLanguageNameGLSL_ES",SWIG_From_int(static_cast< int >(lldb::eLanguageNameGLSL_ES)));
  SWIG_Python_SetConstant(d, "eLanguageNameHLSL",SWIG_From_int(static_cast< int >(lldb::eLanguageNameHLSL)));
  SWIG_Python_SetConstant(d, "eLanguageNameOpenCL_CPP",SWIG_From_int(static_cast< int >(lldb::eLanguageNameOpenCL_CPP)));
  SWIG_Python_SetConstant(d, "eLanguageNameCPP_for_OpenCL",SWIG_From_int(static_cast< int >(lldb::eLanguageNameCPP_for_OpenCL)));
  SWIG_Python_SetConstant(d, "eLanguageNameSYCL",SWIG_From_int(static_cast< int >(lldb::eLanguageNameSYCL)));
  SWIG_Python_SetConstant(d, "eLanguageNameRuby",SWIG_From_int(static_cast< int >(lldb::eLanguageNameRuby)));
  SWIG_Python_SetConstant(d, "eLanguageNameMove",SWIG_From_int(static_cast< int >(lldb::eLanguageNameMove)));
  SWIG_Python_SetConstant(d, "eLanguageNameHylo",SWIG_From_int(static_cast< int >(lldb::eLanguageNameHylo)));
  SWIG_Python_SetConstant(d, "eLanguageNameMetal",SWIG_From_int(static_cast< int >(lldb::eLanguageNameMetal)));
  SWIG_Python_SetConstant(d, "SBProcess_eBroadcastBitStateChanged",SWIG_From_int(static_cast< int >(lldb::SBProcess::eBroadcastBitStateChanged)));
  SWIG_Python_SetConstant(d, "SBProcess_eBroadcastBitInterrupt",SWIG_From_int(static_cast< int >(lldb::SBProcess::eBroadcastBitInterrupt)));
  SWIG_Python_SetConstant(d, "SBProcess_eBroadcastBitSTDOUT",SWIG_From_int(static_cast< int >(lldb::SBProcess::eBroadcastBitSTDOUT)));
  SWIG_Python_SetConstant(d, "SBProcess_eBroadcastBitSTDERR",SWIG_From_int(static_cast< int >(lldb::SBProcess::eBroadcastBitSTDERR)));
  SWIG_Python_SetConstant(d, "SBProcess_eBroadcastBitProfileData",SWIG_From_int(static_cast< int >(lldb::SBProcess::eBroadcastBitProfileData)));
  SWIG_Python_SetConstant(d, "SBProcess_eBroadcastBitStructuredData",SWIG_From_int(static_cast< int >(lldb::SBProcess::eBroadcastBitStructuredData)));
  SWIG_Python_SetConstant(d, "SBTarget_eBroadcastBitBreakpointChanged",SWIG_From_int(static_cast< int >(lldb::SBTarget::eBroadcastBitBreakpointChanged)));
  SWIG_Python_SetConstant(d, "SBTarget_eBroadcastBitModulesLoaded",SWIG_From_int(static_cast< int >(lldb::SBTarget::eBroadcastBitModulesLoaded)));
  SWIG_Python_SetConstant(d, "SBTarget_eBroadcastBitModulesUnloaded",SWIG_From_int(static_cast< int >(lldb::SBTarget::eBroadcastBitModulesUnloaded)));
  SWIG_Python_SetConstant(d, "SBTarget_eBroadcastBitWatchpointChanged",SWIG_From_int(static_cast< int >(lldb::SBTarget::eBroadcastBitWatchpointChanged)));
  SWIG_Python_SetConstant(d, "SBTarget_eBroadcastBitSymbolsLoaded",SWIG_From_int(static_cast< int >(lldb::SBTarget::eBroadcastBitSymbolsLoaded)));
  SWIG_Python_SetConstant(d, "SBTarget_eBroadcastBitSymbolsChanged",SWIG_From_int(static_cast< int >(lldb::SBTarget::eBroadcastBitSymbolsChanged)));
  SWIG_Python_SetConstant(d, "SBTarget_eBroadcastBitNewTargetCreated",SWIG_From_int(static_cast< int >(lldb::SBTarget::eBroadcastBitNewTargetCreated)));
  SWIG_Python_SetConstant(d, "SBThread_eBroadcastBitStackChanged",SWIG_From_int(static_cast< int >(lldb::SBThread::eBroadcastBitStackChanged)));
  SWIG_Python_SetConstant(d, "SBThread_eBroadcastBitThreadSuspended",SWIG_From_int(static_cast< int >(lldb::SBThread::eBroadcastBitThreadSuspended)));
  SWIG_Python_SetConstant(d, "SBThread_eBroadcastBitThreadResumed",SWIG_From_int(static_cast< int >(lldb::SBThread::eBroadcastBitThreadResumed)));
  SWIG_Python_SetConstant(d, "SBThread_eBroadcastBitSelectedFrameChanged",SWIG_From_int(static_cast< int >(lldb::SBThread::eBroadcastBitSelectedFrameChanged)));
  SWIG_Python_SetConstant(d, "SBThread_eBroadcastBitThreadSelected",SWIG_From_int(static_cast< int >(lldb::SBThread::eBroadcastBitThreadSelected)));
  
  /* Initialize threading */
  SWIG_PYTHON_INITIALIZE_THREADS;
  return 0;
}

